(function webpackUniversalModuleDefinition(root, factory) {
    if (typeof exports === "object" && typeof module === "object")
        module.exports = factory();
    else if (typeof define === "function" && define.amd) define([], factory);
    else if (typeof exports === "object") exports["jsQR"] = factory();
    else root["jsQR"] = factory();
})(typeof self !== "undefined" ? self : this, function () {
    return /******/ (function (modules) {
        // webpackBootstrap
        /******/ // The module cache
        /******/ var installedModules = {};
        /******/
        /******/ // The require function
        /******/ function __webpack_require__(moduleId) {
            /******/
            /******/ // Check if module is in cache
            /******/ if (installedModules[moduleId]) {
                /******/ return installedModules[moduleId].exports;
                /******/
            }
            /******/ // Create a new module (and put it into the cache)
            /******/ var module = (installedModules[moduleId] = {
                /******/ i: moduleId,
                /******/ l: false,
                /******/ exports: {},
                /******/
            });
            /******/
            /******/ // Execute the module function
            /******/ modules[moduleId].call(
                module.exports,
                module,
                module.exports,
                __webpack_require__
            );
            /******/
            /******/ // Flag the module as loaded
            /******/ module.l = true;
            /******/
            /******/ // Return the exports of the module
            /******/ return module.exports;
            /******/
        }
        /******/
        /******/
        /******/ // expose the modules object (__webpack_modules__)
        /******/ __webpack_require__.m = modules;
        /******/
        /******/ // expose the module cache
        /******/ __webpack_require__.c = installedModules;
        /******/
        /******/ // define getter function for harmony exports
        /******/ __webpack_require__.d = function (exports, name, getter) {
            /******/ if (!__webpack_require__.o(exports, name)) {
                /******/ Object.defineProperty(exports, name, {
                    /******/ configurable: false,
                    /******/ enumerable: true,
                    /******/ get: getter,
                    /******/
                });
                /******/
            }
            /******/
        };
        /******/
        /******/ // getDefaultExport function for compatibility with non-harmony modules
        /******/ __webpack_require__.n = function (module) {
            /******/ var getter =
                module && module.__esModule
                    ? /******/ function getDefault() {
                          return module["default"];
                      }
                    : /******/ function getModuleExports() {
                          return module;
                      };
            /******/ __webpack_require__.d(getter, "a", getter);
            /******/ return getter;
            /******/
        };
        /******/
        /******/ // Object.prototype.hasOwnProperty.call
        /******/ __webpack_require__.o = function (object, property) {
            return Object.prototype.hasOwnProperty.call(object, property);
        };
        /******/
        /******/ // __webpack_public_path__
        /******/ __webpack_require__.p = "";
        /******/
        /******/ // Load entry module and return exports
        /******/ return __webpack_require__((__webpack_require__.s = 3));
        /******/
    })(
        /************************************************************************/
        /******/ [
            /* 0 */
            /***/ function (module, exports, __webpack_require__) {
                "use strict";

                Object.defineProperty(exports, "__esModule", { value: true });
                var BitMatrix = /** @class */ (function () {
                    function BitMatrix(data, width) {
                        this.width = width;
                        this.height = data.length / width;
                        this.data = data;
                    }
                    BitMatrix.createEmpty = function (width, height) {
                        return new BitMatrix(
                            new Uint8ClampedArray(width * height),
                            width
                        );
                    };
                    BitMatrix.prototype.get = function (x, y) {
                        if (
                            x < 0 ||
                            x >= this.width ||
                            y < 0 ||
                            y >= this.height
                        ) {
                            return false;
                        }
                        return !!this.data[y * this.width + x];
                    };
                    BitMatrix.prototype.set = function (x, y, v) {
                        this.data[y * this.width + x] = v ? 1 : 0;
                    };
                    BitMatrix.prototype.setRegion = function (
                        left,
                        top,
                        width,
                        height,
                        v
                    ) {
                        for (var y = top; y < top + height; y++) {
                            for (var x = left; x < left + width; x++) {
                                this.set(x, y, !!v);
                            }
                        }
                    };
                    return BitMatrix;
                })();
                exports.BitMatrix = BitMatrix;

                /***/
            },
            /* 1 */
            /***/ function (module, exports, __webpack_require__) {
                "use strict";

                Object.defineProperty(exports, "__esModule", { value: true });
                var GenericGFPoly_1 = __webpack_require__(2);
                function addOrSubtractGF(a, b) {
                    return a ^ b; // tslint:disable-line:no-bitwise
                }
                exports.addOrSubtractGF = addOrSubtractGF;
                var GenericGF = /** @class */ (function () {
                    function GenericGF(primitive, size, genBase) {
                        this.primitive = primitive;
                        this.size = size;
                        this.generatorBase = genBase;
                        this.expTable = new Array(this.size);
                        this.logTable = new Array(this.size);
                        var x = 1;
                        for (var i = 0; i < this.size; i++) {
                            this.expTable[i] = x;
                            x = x * 2;
                            if (x >= this.size) {
                                x = (x ^ this.primitive) & (this.size - 1); // tslint:disable-line:no-bitwise
                            }
                        }
                        for (var i = 0; i < this.size - 1; i++) {
                            this.logTable[this.expTable[i]] = i;
                        }
                        this.zero = new GenericGFPoly_1.default(
                            this,
                            Uint8ClampedArray.from([0])
                        );
                        this.one = new GenericGFPoly_1.default(
                            this,
                            Uint8ClampedArray.from([1])
                        );
                    }
                    GenericGF.prototype.multiply = function (a, b) {
                        if (a === 0 || b === 0) {
                            return 0;
                        }
                        return this.expTable[
                            (this.logTable[a] + this.logTable[b]) %
                                (this.size - 1)
                        ];
                    };
                    GenericGF.prototype.inverse = function (a) {
                        if (a === 0) {
                            throw new Error("Can't invert 0");
                        }
                        return this.expTable[this.size - this.logTable[a] - 1];
                    };
                    GenericGF.prototype.buildMonomial = function (
                        degree,
                        coefficient
                    ) {
                        if (degree < 0) {
                            throw new Error(
                                "Invalid monomial degree less than 0"
                            );
                        }
                        if (coefficient === 0) {
                            return this.zero;
                        }
                        var coefficients = new Uint8ClampedArray(degree + 1);
                        coefficients[0] = coefficient;
                        return new GenericGFPoly_1.default(this, coefficients);
                    };
                    GenericGF.prototype.log = function (a) {
                        if (a === 0) {
                            throw new Error("Can't take log(0)");
                        }
                        return this.logTable[a];
                    };
                    GenericGF.prototype.exp = function (a) {
                        return this.expTable[a];
                    };
                    return GenericGF;
                })();
                exports.default = GenericGF;

                /***/
            },
            /* 2 */
            /***/ function (module, exports, __webpack_require__) {
                "use strict";

                Object.defineProperty(exports, "__esModule", { value: true });
                var GenericGF_1 = __webpack_require__(1);
                var GenericGFPoly = /** @class */ (function () {
                    function GenericGFPoly(field, coefficients) {
                        if (coefficients.length === 0) {
                            throw new Error("No coefficients.");
                        }
                        this.field = field;
                        var coefficientsLength = coefficients.length;
                        if (coefficientsLength > 1 && coefficients[0] === 0) {
                            // Leading term must be non-zero for anything except the constant polynomial "0"
                            var firstNonZero = 1;
                            while (
                                firstNonZero < coefficientsLength &&
                                coefficients[firstNonZero] === 0
                            ) {
                                firstNonZero++;
                            }
                            if (firstNonZero === coefficientsLength) {
                                this.coefficients = field.zero.coefficients;
                            } else {
                                this.coefficients = new Uint8ClampedArray(
                                    coefficientsLength - firstNonZero
                                );
                                for (
                                    var i = 0;
                                    i < this.coefficients.length;
                                    i++
                                ) {
                                    this.coefficients[i] =
                                        coefficients[firstNonZero + i];
                                }
                            }
                        } else {
                            this.coefficients = coefficients;
                        }
                    }
                    GenericGFPoly.prototype.degree = function () {
                        return this.coefficients.length - 1;
                    };
                    GenericGFPoly.prototype.isZero = function () {
                        return this.coefficients[0] === 0;
                    };
                    GenericGFPoly.prototype.getCoefficient = function (degree) {
                        return this.coefficients[
                            this.coefficients.length - 1 - degree
                        ];
                    };
                    GenericGFPoly.prototype.addOrSubtract = function (other) {
                        var _a;
                        if (this.isZero()) {
                            return other;
                        }
                        if (other.isZero()) {
                            return this;
                        }
                        var smallerCoefficients = this.coefficients;
                        var largerCoefficients = other.coefficients;
                        if (
                            smallerCoefficients.length >
                            largerCoefficients.length
                        ) {
                            (_a = [largerCoefficients, smallerCoefficients]),
                                (smallerCoefficients = _a[0]),
                                (largerCoefficients = _a[1]);
                        }
                        var sumDiff = new Uint8ClampedArray(
                            largerCoefficients.length
                        );
                        var lengthDiff =
                            largerCoefficients.length -
                            smallerCoefficients.length;
                        for (var i = 0; i < lengthDiff; i++) {
                            sumDiff[i] = largerCoefficients[i];
                        }
                        for (
                            var i = lengthDiff;
                            i < largerCoefficients.length;
                            i++
                        ) {
                            sumDiff[i] = GenericGF_1.addOrSubtractGF(
                                smallerCoefficients[i - lengthDiff],
                                largerCoefficients[i]
                            );
                        }
                        return new GenericGFPoly(this.field, sumDiff);
                    };
                    GenericGFPoly.prototype.multiply = function (scalar) {
                        if (scalar === 0) {
                            return this.field.zero;
                        }
                        if (scalar === 1) {
                            return this;
                        }
                        var size = this.coefficients.length;
                        var product = new Uint8ClampedArray(size);
                        for (var i = 0; i < size; i++) {
                            product[i] = this.field.multiply(
                                this.coefficients[i],
                                scalar
                            );
                        }
                        return new GenericGFPoly(this.field, product);
                    };
                    GenericGFPoly.prototype.multiplyPoly = function (other) {
                        if (this.isZero() || other.isZero()) {
                            return this.field.zero;
                        }
                        var aCoefficients = this.coefficients;
                        var aLength = aCoefficients.length;
                        var bCoefficients = other.coefficients;
                        var bLength = bCoefficients.length;
                        var product = new Uint8ClampedArray(
                            aLength + bLength - 1
                        );
                        for (var i = 0; i < aLength; i++) {
                            var aCoeff = aCoefficients[i];
                            for (var j = 0; j < bLength; j++) {
                                product[i + j] = GenericGF_1.addOrSubtractGF(
                                    product[i + j],
                                    this.field.multiply(
                                        aCoeff,
                                        bCoefficients[j]
                                    )
                                );
                            }
                        }
                        return new GenericGFPoly(this.field, product);
                    };
                    GenericGFPoly.prototype.multiplyByMonomial = function (
                        degree,
                        coefficient
                    ) {
                        if (degree < 0) {
                            throw new Error("Invalid degree less than 0");
                        }
                        if (coefficient === 0) {
                            return this.field.zero;
                        }
                        var size = this.coefficients.length;
                        var product = new Uint8ClampedArray(size + degree);
                        for (var i = 0; i < size; i++) {
                            product[i] = this.field.multiply(
                                this.coefficients[i],
                                coefficient
                            );
                        }
                        return new GenericGFPoly(this.field, product);
                    };
                    GenericGFPoly.prototype.evaluateAt = function (a) {
                        var result = 0;
                        if (a === 0) {
                            // Just return the x^0 coefficient
                            return this.getCoefficient(0);
                        }
                        var size = this.coefficients.length;
                        if (a === 1) {
                            // Just the sum of the coefficients
                            this.coefficients.forEach(function (coefficient) {
                                result = GenericGF_1.addOrSubtractGF(
                                    result,
                                    coefficient
                                );
                            });
                            return result;
                        }
                        result = this.coefficients[0];
                        for (var i = 1; i < size; i++) {
                            result = GenericGF_1.addOrSubtractGF(
                                this.field.multiply(a, result),
                                this.coefficients[i]
                            );
                        }
                        return result;
                    };
                    return GenericGFPoly;
                })();
                exports.default = GenericGFPoly;

                /***/
            },
            /* 3 */
            /***/ function (module, exports, __webpack_require__) {
                "use strict";

                Object.defineProperty(exports, "__esModule", { value: true });
                var binarizer_1 = __webpack_require__(4);
                var decoder_1 = __webpack_require__(5);
                var extractor_1 = __webpack_require__(11);
                var locator_1 = __webpack_require__(12);
                function scan(matrix) {
                    var locations = locator_1.locate(matrix);
                    if (!locations) {
                        return null;
                    }
                    for (
                        var _i = 0, locations_1 = locations;
                        _i < locations_1.length;
                        _i++
                    ) {
                        var location_1 = locations_1[_i];
                        var extracted = extractor_1.extract(matrix, location_1);
                        var decoded = decoder_1.decode(extracted.matrix);
                        if (decoded) {
                            return {
                                binaryData: decoded.bytes,
                                data: decoded.text,
                                chunks: decoded.chunks,
                                version: decoded.version,
                                location: {
                                    topRightCorner: extracted.mappingFunction(
                                        location_1.dimension,
                                        0
                                    ),
                                    topLeftCorner: extracted.mappingFunction(
                                        0,
                                        0
                                    ),
                                    bottomRightCorner:
                                        extracted.mappingFunction(
                                            location_1.dimension,
                                            location_1.dimension
                                        ),
                                    bottomLeftCorner: extracted.mappingFunction(
                                        0,
                                        location_1.dimension
                                    ),
                                    topRightFinderPattern: location_1.topRight,
                                    topLeftFinderPattern: location_1.topLeft,
                                    bottomLeftFinderPattern:
                                        location_1.bottomLeft,
                                    bottomRightAlignmentPattern:
                                        location_1.alignmentPattern,
                                },
                            };
                        }
                    }
                    return null;
                }
                var defaultOptions = {
                    inversionAttempts: "attemptBoth",
                };
                function jsQR(data, width, height, providedOptions) {
                    if (providedOptions === void 0) {
                        providedOptions = {};
                    }
                    var options = defaultOptions;
                    Object.keys(options || {}).forEach(function (opt) {
                        options[opt] = providedOptions[opt] || options[opt];
                    });
                    var shouldInvert =
                        options.inversionAttempts === "attemptBoth" ||
                        options.inversionAttempts === "invertFirst";
                    var tryInvertedFirst =
                        options.inversionAttempts === "onlyInvert" ||
                        options.inversionAttempts === "invertFirst";
                    var _a = binarizer_1.binarize(
                            data,
                            width,
                            height,
                            shouldInvert
                        ),
                        binarized = _a.binarized,
                        inverted = _a.inverted;
                    var result = scan(tryInvertedFirst ? inverted : binarized);
                    if (
                        !result &&
                        (options.inversionAttempts === "attemptBoth" ||
                            options.inversionAttempts === "invertFirst")
                    ) {
                        result = scan(tryInvertedFirst ? binarized : inverted);
                    }
                    return result;
                }
                jsQR.default = jsQR;
                exports.default = jsQR;

                /***/
            },
            /* 4 */
            /***/ function (module, exports, __webpack_require__) {
                "use strict";

                Object.defineProperty(exports, "__esModule", { value: true });
                var BitMatrix_1 = __webpack_require__(0);
                var REGION_SIZE = 8;
                var MIN_DYNAMIC_RANGE = 24;
                function numBetween(value, min, max) {
                    return value < min ? min : value > max ? max : value;
                }
                // Like BitMatrix but accepts arbitry Uint8 values
                var Matrix = /** @class */ (function () {
                    function Matrix(width, height) {
                        this.width = width;
                        this.data = new Uint8ClampedArray(width * height);
                    }
                    Matrix.prototype.get = function (x, y) {
                        return this.data[y * this.width + x];
                    };
                    Matrix.prototype.set = function (x, y, value) {
                        this.data[y * this.width + x] = value;
                    };
                    return Matrix;
                })();
                function binarize(data, width, height, returnInverted) {
                    if (data.length !== width * height * 4) {
                        throw new Error("Malformed data passed to binarizer.");
                    }
                    // Convert image to greyscale
                    var greyscalePixels = new Matrix(width, height);
                    for (var x = 0; x < width; x++) {
                        for (var y = 0; y < height; y++) {
                            var r = data[(y * width + x) * 4 + 0];
                            var g = data[(y * width + x) * 4 + 1];
                            var b = data[(y * width + x) * 4 + 2];
                            greyscalePixels.set(
                                x,
                                y,
                                0.2126 * r + 0.7152 * g + 0.0722 * b
                            );
                        }
                    }
                    var horizontalRegionCount = Math.ceil(width / REGION_SIZE);
                    var verticalRegionCount = Math.ceil(height / REGION_SIZE);
                    var blackPoints = new Matrix(
                        horizontalRegionCount,
                        verticalRegionCount
                    );
                    for (
                        var verticalRegion = 0;
                        verticalRegion < verticalRegionCount;
                        verticalRegion++
                    ) {
                        for (
                            var hortizontalRegion = 0;
                            hortizontalRegion < horizontalRegionCount;
                            hortizontalRegion++
                        ) {
                            var sum = 0;
                            var min = Infinity;
                            var max = 0;
                            for (var y = 0; y < REGION_SIZE; y++) {
                                for (var x = 0; x < REGION_SIZE; x++) {
                                    var pixelLumosity = greyscalePixels.get(
                                        hortizontalRegion * REGION_SIZE + x,
                                        verticalRegion * REGION_SIZE + y
                                    );
                                    sum += pixelLumosity;
                                    min = Math.min(min, pixelLumosity);
                                    max = Math.max(max, pixelLumosity);
                                }
                            }
                            var average = sum / Math.pow(REGION_SIZE, 2);
                            if (max - min <= MIN_DYNAMIC_RANGE) {
                                // If variation within the block is low, assume this is a block with only light or only
                                // dark pixels. In that case we do not want to use the average, as it would divide this
                                // low contrast area into black and white pixels, essentially creating data out of noise.
                                //
                                // Default the blackpoint for these blocks to be half the min - effectively white them out
                                average = min / 2;
                                if (
                                    verticalRegion > 0 &&
                                    hortizontalRegion > 0
                                ) {
                                    // Correct the "white background" assumption for blocks that have neighbors by comparing
                                    // the pixels in this block to the previously calculated black points. This is based on
                                    // the fact that dark barcode symbology is always surrounded by some amount of light
                                    // background for which reasonable black point estimates were made. The bp estimated at
                                    // the boundaries is used for the interior.
                                    // The (min < bp) is arbitrary but works better than other heuristics that were tried.
                                    var averageNeighborBlackPoint =
                                        (blackPoints.get(
                                            hortizontalRegion,
                                            verticalRegion - 1
                                        ) +
                                            2 *
                                                blackPoints.get(
                                                    hortizontalRegion - 1,
                                                    verticalRegion
                                                ) +
                                            blackPoints.get(
                                                hortizontalRegion - 1,
                                                verticalRegion - 1
                                            )) /
                                        4;
                                    if (min < averageNeighborBlackPoint) {
                                        average = averageNeighborBlackPoint;
                                    }
                                }
                            }
                            blackPoints.set(
                                hortizontalRegion,
                                verticalRegion,
                                average
                            );
                        }
                    }
                    var binarized = BitMatrix_1.BitMatrix.createEmpty(
                        width,
                        height
                    );
                    var inverted = null;
                    if (returnInverted) {
                        inverted = BitMatrix_1.BitMatrix.createEmpty(
                            width,
                            height
                        );
                    }
                    for (
                        var verticalRegion = 0;
                        verticalRegion < verticalRegionCount;
                        verticalRegion++
                    ) {
                        for (
                            var hortizontalRegion = 0;
                            hortizontalRegion < horizontalRegionCount;
                            hortizontalRegion++
                        ) {
                            var left = numBetween(
                                hortizontalRegion,
                                2,
                                horizontalRegionCount - 3
                            );
                            var top_1 = numBetween(
                                verticalRegion,
                                2,
                                verticalRegionCount - 3
                            );
                            var sum = 0;
                            for (var xRegion = -2; xRegion <= 2; xRegion++) {
                                for (
                                    var yRegion = -2;
                                    yRegion <= 2;
                                    yRegion++
                                ) {
                                    sum += blackPoints.get(
                                        left + xRegion,
                                        top_1 + yRegion
                                    );
                                }
                            }
                            var threshold = sum / 25;
                            for (
                                var xRegion = 0;
                                xRegion < REGION_SIZE;
                                xRegion++
                            ) {
                                for (
                                    var yRegion = 0;
                                    yRegion < REGION_SIZE;
                                    yRegion++
                                ) {
                                    var x =
                                        hortizontalRegion * REGION_SIZE +
                                        xRegion;
                                    var y =
                                        verticalRegion * REGION_SIZE + yRegion;
                                    var lum = greyscalePixels.get(x, y);
                                    binarized.set(x, y, lum <= threshold);
                                    if (returnInverted) {
                                        inverted.set(x, y, !(lum <= threshold));
                                    }
                                }
                            }
                        }
                    }
                    if (returnInverted) {
                        return { binarized: binarized, inverted: inverted };
                    }
                    return { binarized: binarized };
                }
                exports.binarize = binarize;

                /***/
            },
            /* 5 */
            /***/ function (module, exports, __webpack_require__) {
                "use strict";

                Object.defineProperty(exports, "__esModule", { value: true });
                var BitMatrix_1 = __webpack_require__(0);
                var decodeData_1 = __webpack_require__(6);
                var reedsolomon_1 = __webpack_require__(9);
                var version_1 = __webpack_require__(10);
                // tslint:disable:no-bitwise
                function numBitsDiffering(x, y) {
                    var z = x ^ y;
                    var bitCount = 0;
                    while (z) {
                        bitCount++;
                        z &= z - 1;
                    }
                    return bitCount;
                }
                function pushBit(bit, byte) {
                    return (byte << 1) | bit;
                }
                // tslint:enable:no-bitwise
                var FORMAT_INFO_TABLE = [
                    {
                        bits: 0x5412,
                        formatInfo: { errorCorrectionLevel: 1, dataMask: 0 },
                    },
                    {
                        bits: 0x5125,
                        formatInfo: { errorCorrectionLevel: 1, dataMask: 1 },
                    },
                    {
                        bits: 0x5e7c,
                        formatInfo: { errorCorrectionLevel: 1, dataMask: 2 },
                    },
                    {
                        bits: 0x5b4b,
                        formatInfo: { errorCorrectionLevel: 1, dataMask: 3 },
                    },
                    {
                        bits: 0x45f9,
                        formatInfo: { errorCorrectionLevel: 1, dataMask: 4 },
                    },
                    {
                        bits: 0x40ce,
                        formatInfo: { errorCorrectionLevel: 1, dataMask: 5 },
                    },
                    {
                        bits: 0x4f97,
                        formatInfo: { errorCorrectionLevel: 1, dataMask: 6 },
                    },
                    {
                        bits: 0x4aa0,
                        formatInfo: { errorCorrectionLevel: 1, dataMask: 7 },
                    },
                    {
                        bits: 0x77c4,
                        formatInfo: { errorCorrectionLevel: 0, dataMask: 0 },
                    },
                    {
                        bits: 0x72f3,
                        formatInfo: { errorCorrectionLevel: 0, dataMask: 1 },
                    },
                    {
                        bits: 0x7daa,
                        formatInfo: { errorCorrectionLevel: 0, dataMask: 2 },
                    },
                    {
                        bits: 0x789d,
                        formatInfo: { errorCorrectionLevel: 0, dataMask: 3 },
                    },
                    {
                        bits: 0x662f,
                        formatInfo: { errorCorrectionLevel: 0, dataMask: 4 },
                    },
                    {
                        bits: 0x6318,
                        formatInfo: { errorCorrectionLevel: 0, dataMask: 5 },
                    },
                    {
                        bits: 0x6c41,
                        formatInfo: { errorCorrectionLevel: 0, dataMask: 6 },
                    },
                    {
                        bits: 0x6976,
                        formatInfo: { errorCorrectionLevel: 0, dataMask: 7 },
                    },
                    {
                        bits: 0x1689,
                        formatInfo: { errorCorrectionLevel: 3, dataMask: 0 },
                    },
                    {
                        bits: 0x13be,
                        formatInfo: { errorCorrectionLevel: 3, dataMask: 1 },
                    },
                    {
                        bits: 0x1ce7,
                        formatInfo: { errorCorrectionLevel: 3, dataMask: 2 },
                    },
                    {
                        bits: 0x19d0,
                        formatInfo: { errorCorrectionLevel: 3, dataMask: 3 },
                    },
                    {
                        bits: 0x0762,
                        formatInfo: { errorCorrectionLevel: 3, dataMask: 4 },
                    },
                    {
                        bits: 0x0255,
                        formatInfo: { errorCorrectionLevel: 3, dataMask: 5 },
                    },
                    {
                        bits: 0x0d0c,
                        formatInfo: { errorCorrectionLevel: 3, dataMask: 6 },
                    },
                    {
                        bits: 0x083b,
                        formatInfo: { errorCorrectionLevel: 3, dataMask: 7 },
                    },
                    {
                        bits: 0x355f,
                        formatInfo: { errorCorrectionLevel: 2, dataMask: 0 },
                    },
                    {
                        bits: 0x3068,
                        formatInfo: { errorCorrectionLevel: 2, dataMask: 1 },
                    },
                    {
                        bits: 0x3f31,
                        formatInfo: { errorCorrectionLevel: 2, dataMask: 2 },
                    },
                    {
                        bits: 0x3a06,
                        formatInfo: { errorCorrectionLevel: 2, dataMask: 3 },
                    },
                    {
                        bits: 0x24b4,
                        formatInfo: { errorCorrectionLevel: 2, dataMask: 4 },
                    },
                    {
                        bits: 0x2183,
                        formatInfo: { errorCorrectionLevel: 2, dataMask: 5 },
                    },
                    {
                        bits: 0x2eda,
                        formatInfo: { errorCorrectionLevel: 2, dataMask: 6 },
                    },
                    {
                        bits: 0x2bed,
                        formatInfo: { errorCorrectionLevel: 2, dataMask: 7 },
                    },
                ];
                var DATA_MASKS = [
                    function (p) {
                        return (p.y + p.x) % 2 === 0;
                    },
                    function (p) {
                        return p.y % 2 === 0;
                    },
                    function (p) {
                        return p.x % 3 === 0;
                    },
                    function (p) {
                        return (p.y + p.x) % 3 === 0;
                    },
                    function (p) {
                        return (
                            (Math.floor(p.y / 2) + Math.floor(p.x / 3)) % 2 ===
                            0
                        );
                    },
                    function (p) {
                        return ((p.x * p.y) % 2) + ((p.x * p.y) % 3) === 0;
                    },
                    function (p) {
                        return (
                            (((p.y * p.x) % 2) + ((p.y * p.x) % 3)) % 2 === 0
                        );
                    },
                    function (p) {
                        return (
                            (((p.y + p.x) % 2) + ((p.y * p.x) % 3)) % 2 === 0
                        );
                    },
                ];
                function buildFunctionPatternMask(version) {
                    var dimension = 17 + 4 * version.versionNumber;
                    var matrix = BitMatrix_1.BitMatrix.createEmpty(
                        dimension,
                        dimension
                    );
                    matrix.setRegion(0, 0, 9, 9, true); // Top left finder pattern + separator + format
                    matrix.setRegion(dimension - 8, 0, 8, 9, true); // Top right finder pattern + separator + format
                    matrix.setRegion(0, dimension - 8, 9, 8, true); // Bottom left finder pattern + separator + format
                    // Alignment patterns
                    for (
                        var _i = 0, _a = version.alignmentPatternCenters;
                        _i < _a.length;
                        _i++
                    ) {
                        var x = _a[_i];
                        for (
                            var _b = 0, _c = version.alignmentPatternCenters;
                            _b < _c.length;
                            _b++
                        ) {
                            var y = _c[_b];
                            if (
                                !(
                                    (x === 6 && y === 6) ||
                                    (x === 6 && y === dimension - 7) ||
                                    (x === dimension - 7 && y === 6)
                                )
                            ) {
                                matrix.setRegion(x - 2, y - 2, 5, 5, true);
                            }
                        }
                    }
                    matrix.setRegion(6, 9, 1, dimension - 17, true); // Vertical timing pattern
                    matrix.setRegion(9, 6, dimension - 17, 1, true); // Horizontal timing pattern
                    if (version.versionNumber > 6) {
                        matrix.setRegion(dimension - 11, 0, 3, 6, true); // Version info, top right
                        matrix.setRegion(0, dimension - 11, 6, 3, true); // Version info, bottom left
                    }
                    return matrix;
                }
                function readCodewords(matrix, version, formatInfo) {
                    var dataMask = DATA_MASKS[formatInfo.dataMask];
                    var dimension = matrix.height;
                    var functionPatternMask = buildFunctionPatternMask(version);
                    var codewords = [];
                    var currentByte = 0;
                    var bitsRead = 0;
                    // Read columns in pairs, from right to left
                    var readingUp = true;
                    for (
                        var columnIndex = dimension - 1;
                        columnIndex > 0;
                        columnIndex -= 2
                    ) {
                        if (columnIndex === 6) {
                            // Skip whole column with vertical alignment pattern;
                            columnIndex--;
                        }
                        for (var i = 0; i < dimension; i++) {
                            var y = readingUp ? dimension - 1 - i : i;
                            for (
                                var columnOffset = 0;
                                columnOffset < 2;
                                columnOffset++
                            ) {
                                var x = columnIndex - columnOffset;
                                if (!functionPatternMask.get(x, y)) {
                                    bitsRead++;
                                    var bit = matrix.get(x, y);
                                    if (dataMask({ y: y, x: x })) {
                                        bit = !bit;
                                    }
                                    currentByte = pushBit(bit, currentByte);
                                    if (bitsRead === 8) {
                                        // Whole bytes
                                        codewords.push(currentByte);
                                        bitsRead = 0;
                                        currentByte = 0;
                                    }
                                }
                            }
                        }
                        readingUp = !readingUp;
                    }
                    return codewords;
                }
                function readVersion(matrix) {
                    var dimension = matrix.height;
                    var provisionalVersion = Math.floor((dimension - 17) / 4);
                    if (provisionalVersion <= 6) {
                        // 6 and under dont have version info in the QR code
                        return version_1.VERSIONS[provisionalVersion - 1];
                    }
                    var topRightVersionBits = 0;
                    for (var y = 5; y >= 0; y--) {
                        for (var x = dimension - 9; x >= dimension - 11; x--) {
                            topRightVersionBits = pushBit(
                                matrix.get(x, y),
                                topRightVersionBits
                            );
                        }
                    }
                    var bottomLeftVersionBits = 0;
                    for (var x = 5; x >= 0; x--) {
                        for (var y = dimension - 9; y >= dimension - 11; y--) {
                            bottomLeftVersionBits = pushBit(
                                matrix.get(x, y),
                                bottomLeftVersionBits
                            );
                        }
                    }
                    var bestDifference = Infinity;
                    var bestVersion;
                    for (
                        var _i = 0, VERSIONS_1 = version_1.VERSIONS;
                        _i < VERSIONS_1.length;
                        _i++
                    ) {
                        var version = VERSIONS_1[_i];
                        if (
                            version.infoBits === topRightVersionBits ||
                            version.infoBits === bottomLeftVersionBits
                        ) {
                            return version;
                        }
                        var difference = numBitsDiffering(
                            topRightVersionBits,
                            version.infoBits
                        );
                        if (difference < bestDifference) {
                            bestVersion = version;
                            bestDifference = difference;
                        }
                        difference = numBitsDiffering(
                            bottomLeftVersionBits,
                            version.infoBits
                        );
                        if (difference < bestDifference) {
                            bestVersion = version;
                            bestDifference = difference;
                        }
                    }
                    // We can tolerate up to 3 bits of error since no two version info codewords will
                    // differ in less than 8 bits.
                    if (bestDifference <= 3) {
                        return bestVersion;
                    }
                }
                function readFormatInformation(matrix) {
                    var topLeftFormatInfoBits = 0;
                    for (var x = 0; x <= 8; x++) {
                        if (x !== 6) {
                            // Skip timing pattern bit
                            topLeftFormatInfoBits = pushBit(
                                matrix.get(x, 8),
                                topLeftFormatInfoBits
                            );
                        }
                    }
                    for (var y = 7; y >= 0; y--) {
                        if (y !== 6) {
                            // Skip timing pattern bit
                            topLeftFormatInfoBits = pushBit(
                                matrix.get(8, y),
                                topLeftFormatInfoBits
                            );
                        }
                    }
                    var dimension = matrix.height;
                    var topRightBottomRightFormatInfoBits = 0;
                    for (var y = dimension - 1; y >= dimension - 7; y--) {
                        // bottom left
                        topRightBottomRightFormatInfoBits = pushBit(
                            matrix.get(8, y),
                            topRightBottomRightFormatInfoBits
                        );
                    }
                    for (var x = dimension - 8; x < dimension; x++) {
                        // top right
                        topRightBottomRightFormatInfoBits = pushBit(
                            matrix.get(x, 8),
                            topRightBottomRightFormatInfoBits
                        );
                    }
                    var bestDifference = Infinity;
                    var bestFormatInfo = null;
                    for (
                        var _i = 0, FORMAT_INFO_TABLE_1 = FORMAT_INFO_TABLE;
                        _i < FORMAT_INFO_TABLE_1.length;
                        _i++
                    ) {
                        var _a = FORMAT_INFO_TABLE_1[_i],
                            bits = _a.bits,
                            formatInfo = _a.formatInfo;
                        if (
                            bits === topLeftFormatInfoBits ||
                            bits === topRightBottomRightFormatInfoBits
                        ) {
                            return formatInfo;
                        }
                        var difference = numBitsDiffering(
                            topLeftFormatInfoBits,
                            bits
                        );
                        if (difference < bestDifference) {
                            bestFormatInfo = formatInfo;
                            bestDifference = difference;
                        }
                        if (
                            topLeftFormatInfoBits !==
                            topRightBottomRightFormatInfoBits
                        ) {
                            // also try the other option
                            difference = numBitsDiffering(
                                topRightBottomRightFormatInfoBits,
                                bits
                            );
                            if (difference < bestDifference) {
                                bestFormatInfo = formatInfo;
                                bestDifference = difference;
                            }
                        }
                    }
                    // Hamming distance of the 32 masked codes is 7, by construction, so <= 3 bits differing means we found a match
                    if (bestDifference <= 3) {
                        return bestFormatInfo;
                    }
                    return null;
                }
                function getDataBlocks(codewords, version, ecLevel) {
                    var ecInfo = version.errorCorrectionLevels[ecLevel];
                    var dataBlocks = [];
                    var totalCodewords = 0;
                    ecInfo.ecBlocks.forEach(function (block) {
                        for (var i = 0; i < block.numBlocks; i++) {
                            dataBlocks.push({
                                numDataCodewords: block.dataCodewordsPerBlock,
                                codewords: [],
                            });
                            totalCodewords +=
                                block.dataCodewordsPerBlock +
                                ecInfo.ecCodewordsPerBlock;
                        }
                    });
                    // In some cases the QR code will be malformed enough that we pull off more or less than we should.
                    // If we pull off less there's nothing we can do.
                    // If we pull off more we can safely truncate
                    if (codewords.length < totalCodewords) {
                        return null;
                    }
                    codewords = codewords.slice(0, totalCodewords);
                    var shortBlockSize =
                        ecInfo.ecBlocks[0].dataCodewordsPerBlock;
                    // Pull codewords to fill the blocks up to the minimum size
                    for (var i = 0; i < shortBlockSize; i++) {
                        for (
                            var _i = 0, dataBlocks_1 = dataBlocks;
                            _i < dataBlocks_1.length;
                            _i++
                        ) {
                            var dataBlock = dataBlocks_1[_i];
                            dataBlock.codewords.push(codewords.shift());
                        }
                    }
                    // If there are any large blocks, pull codewords to fill the last element of those
                    if (ecInfo.ecBlocks.length > 1) {
                        var smallBlockCount = ecInfo.ecBlocks[0].numBlocks;
                        var largeBlockCount = ecInfo.ecBlocks[1].numBlocks;
                        for (var i = 0; i < largeBlockCount; i++) {
                            dataBlocks[smallBlockCount + i].codewords.push(
                                codewords.shift()
                            );
                        }
                    }
                    // Add the rest of the codewords to the blocks. These are the error correction codewords.
                    while (codewords.length > 0) {
                        for (
                            var _a = 0, dataBlocks_2 = dataBlocks;
                            _a < dataBlocks_2.length;
                            _a++
                        ) {
                            var dataBlock = dataBlocks_2[_a];
                            dataBlock.codewords.push(codewords.shift());
                        }
                    }
                    return dataBlocks;
                }
                function decodeMatrix(matrix) {
                    var version = readVersion(matrix);
                    if (!version) {
                        return null;
                    }
                    var formatInfo = readFormatInformation(matrix);
                    if (!formatInfo) {
                        return null;
                    }
                    var codewords = readCodewords(matrix, version, formatInfo);
                    var dataBlocks = getDataBlocks(
                        codewords,
                        version,
                        formatInfo.errorCorrectionLevel
                    );
                    if (!dataBlocks) {
                        return null;
                    }
                    // Count total number of data bytes
                    var totalBytes = dataBlocks.reduce(function (a, b) {
                        return a + b.numDataCodewords;
                    }, 0);
                    var resultBytes = new Uint8ClampedArray(totalBytes);
                    var resultIndex = 0;
                    for (
                        var _i = 0, dataBlocks_3 = dataBlocks;
                        _i < dataBlocks_3.length;
                        _i++
                    ) {
                        var dataBlock = dataBlocks_3[_i];
                        var correctedBytes = reedsolomon_1.decode(
                            dataBlock.codewords,
                            dataBlock.codewords.length -
                                dataBlock.numDataCodewords
                        );
                        if (!correctedBytes) {
                            return null;
                        }
                        for (var i = 0; i < dataBlock.numDataCodewords; i++) {
                            resultBytes[resultIndex++] = correctedBytes[i];
                        }
                    }
                    try {
                        return decodeData_1.decode(
                            resultBytes,
                            version.versionNumber
                        );
                    } catch (_a) {
                        return null;
                    }
                }
                function decode(matrix) {
                    if (matrix == null) {
                        return null;
                    }
                    var result = decodeMatrix(matrix);
                    if (result) {
                        return result;
                    }
                    // Decoding didn't work, try mirroring the QR across the topLeft -> bottomRight line.
                    for (var x = 0; x < matrix.width; x++) {
                        for (var y = x + 1; y < matrix.height; y++) {
                            if (matrix.get(x, y) !== matrix.get(y, x)) {
                                matrix.set(x, y, !matrix.get(x, y));
                                matrix.set(y, x, !matrix.get(y, x));
                            }
                        }
                    }
                    return decodeMatrix(matrix);
                }
                exports.decode = decode;

                /***/
            },
            /* 6 */
            /***/ function (module, exports, __webpack_require__) {
                "use strict";

                Object.defineProperty(exports, "__esModule", { value: true });
                // tslint:disable:no-bitwise
                var BitStream_1 = __webpack_require__(7);
                var shiftJISTable_1 = __webpack_require__(8);
                var Mode;
                (function (Mode) {
                    Mode["Numeric"] = "numeric";
                    Mode["Alphanumeric"] = "alphanumeric";
                    Mode["Byte"] = "byte";
                    Mode["Kanji"] = "kanji";
                    Mode["ECI"] = "eci";
                })((Mode = exports.Mode || (exports.Mode = {})));
                var ModeByte;
                (function (ModeByte) {
                    ModeByte[(ModeByte["Terminator"] = 0)] = "Terminator";
                    ModeByte[(ModeByte["Numeric"] = 1)] = "Numeric";
                    ModeByte[(ModeByte["Alphanumeric"] = 2)] = "Alphanumeric";
                    ModeByte[(ModeByte["Byte"] = 4)] = "Byte";
                    ModeByte[(ModeByte["Kanji"] = 8)] = "Kanji";
                    ModeByte[(ModeByte["ECI"] = 7)] = "ECI";
                    // StructuredAppend = 0x3,
                    // FNC1FirstPosition = 0x5,
                    // FNC1SecondPosition = 0x9,
                })(ModeByte || (ModeByte = {}));
                function decodeNumeric(stream, size) {
                    var bytes = [];
                    var text = "";
                    var characterCountSize = [10, 12, 14][size];
                    var length = stream.readBits(characterCountSize);
                    // Read digits in groups of 3
                    while (length >= 3) {
                        var num = stream.readBits(10);
                        if (num >= 1000) {
                            throw new Error("Invalid numeric value above 999");
                        }
                        var a = Math.floor(num / 100);
                        var b = Math.floor(num / 10) % 10;
                        var c = num % 10;
                        bytes.push(48 + a, 48 + b, 48 + c);
                        text += a.toString() + b.toString() + c.toString();
                        length -= 3;
                    }
                    // If the number of digits aren't a multiple of 3, the remaining digits are special cased.
                    if (length === 2) {
                        var num = stream.readBits(7);
                        if (num >= 100) {
                            throw new Error("Invalid numeric value above 99");
                        }
                        var a = Math.floor(num / 10);
                        var b = num % 10;
                        bytes.push(48 + a, 48 + b);
                        text += a.toString() + b.toString();
                    } else if (length === 1) {
                        var num = stream.readBits(4);
                        if (num >= 10) {
                            throw new Error("Invalid numeric value above 9");
                        }
                        bytes.push(48 + num);
                        text += num.toString();
                    }
                    return { bytes: bytes, text: text };
                }
                var AlphanumericCharacterCodes = [
                    "0",
                    "1",
                    "2",
                    "3",
                    "4",
                    "5",
                    "6",
                    "7",
                    "8",
                    "9",
                    "A",
                    "B",
                    "C",
                    "D",
                    "E",
                    "F",
                    "G",
                    "H",
                    "I",
                    "J",
                    "K",
                    "L",
                    "M",
                    "N",
                    "O",
                    "P",
                    "Q",
                    "R",
                    "S",
                    "T",
                    "U",
                    "V",
                    "W",
                    "X",
                    "Y",
                    "Z",
                    " ",
                    "$",
                    "%",
                    "*",
                    "+",
                    "-",
                    ".",
                    "/",
                    ":",
                ];
                function decodeAlphanumeric(stream, size) {
                    var bytes = [];
                    var text = "";
                    var characterCountSize = [9, 11, 13][size];
                    var length = stream.readBits(characterCountSize);
                    while (length >= 2) {
                        var v = stream.readBits(11);
                        var a = Math.floor(v / 45);
                        var b = v % 45;
                        bytes.push(
                            AlphanumericCharacterCodes[a].charCodeAt(0),
                            AlphanumericCharacterCodes[b].charCodeAt(0)
                        );
                        text +=
                            AlphanumericCharacterCodes[a] +
                            AlphanumericCharacterCodes[b];
                        length -= 2;
                    }
                    if (length === 1) {
                        var a = stream.readBits(6);
                        bytes.push(AlphanumericCharacterCodes[a].charCodeAt(0));
                        text += AlphanumericCharacterCodes[a];
                    }
                    return { bytes: bytes, text: text };
                }
                function decodeByte(stream, size) {
                    var bytes = [];
                    var text = "";
                    var characterCountSize = [8, 16, 16][size];
                    var length = stream.readBits(characterCountSize);
                    for (var i = 0; i < length; i++) {
                        var b = stream.readBits(8);
                        bytes.push(b);
                    }
                    try {
                        text += decodeURIComponent(
                            bytes
                                .map(function (b) {
                                    return (
                                        "%" + ("0" + b.toString(16)).substr(-2)
                                    );
                                })
                                .join("")
                        );
                    } catch (_a) {
                        // failed to decode
                    }
                    return { bytes: bytes, text: text };
                }
                function decodeKanji(stream, size) {
                    var bytes = [];
                    var text = "";
                    var characterCountSize = [8, 10, 12][size];
                    var length = stream.readBits(characterCountSize);
                    for (var i = 0; i < length; i++) {
                        var k = stream.readBits(13);
                        var c = (Math.floor(k / 0xc0) << 8) | k % 0xc0;
                        if (c < 0x1f00) {
                            c += 0x8140;
                        } else {
                            c += 0xc140;
                        }
                        bytes.push(c >> 8, c & 0xff);
                        text += String.fromCharCode(
                            shiftJISTable_1.shiftJISTable[c]
                        );
                    }
                    return { bytes: bytes, text: text };
                }
                function decode(data, version) {
                    var _a, _b, _c, _d;
                    var stream = new BitStream_1.BitStream(data);
                    // There are 3 'sizes' based on the version. 1-9 is small (0), 10-26 is medium (1) and 27-40 is large (2).
                    var size = version <= 9 ? 0 : version <= 26 ? 1 : 2;
                    var result = {
                        text: "",
                        bytes: [],
                        chunks: [],
                        version: version,
                    };
                    while (stream.available() >= 4) {
                        var mode = stream.readBits(4);
                        if (mode === ModeByte.Terminator) {
                            return result;
                        } else if (mode === ModeByte.ECI) {
                            if (stream.readBits(1) === 0) {
                                result.chunks.push({
                                    type: Mode.ECI,
                                    assignmentNumber: stream.readBits(7),
                                });
                            } else if (stream.readBits(1) === 0) {
                                result.chunks.push({
                                    type: Mode.ECI,
                                    assignmentNumber: stream.readBits(14),
                                });
                            } else if (stream.readBits(1) === 0) {
                                result.chunks.push({
                                    type: Mode.ECI,
                                    assignmentNumber: stream.readBits(21),
                                });
                            } else {
                                // ECI data seems corrupted
                                result.chunks.push({
                                    type: Mode.ECI,
                                    assignmentNumber: -1,
                                });
                            }
                        } else if (mode === ModeByte.Numeric) {
                            var numericResult = decodeNumeric(stream, size);
                            result.text += numericResult.text;
                            (_a = result.bytes).push.apply(
                                _a,
                                numericResult.bytes
                            );
                            result.chunks.push({
                                type: Mode.Numeric,
                                text: numericResult.text,
                            });
                        } else if (mode === ModeByte.Alphanumeric) {
                            var alphanumericResult = decodeAlphanumeric(
                                stream,
                                size
                            );
                            result.text += alphanumericResult.text;
                            (_b = result.bytes).push.apply(
                                _b,
                                alphanumericResult.bytes
                            );
                            result.chunks.push({
                                type: Mode.Alphanumeric,
                                text: alphanumericResult.text,
                            });
                        } else if (mode === ModeByte.Byte) {
                            var byteResult = decodeByte(stream, size);
                            result.text += byteResult.text;
                            (_c = result.bytes).push.apply(
                                _c,
                                byteResult.bytes
                            );
                            result.chunks.push({
                                type: Mode.Byte,
                                bytes: byteResult.bytes,
                                text: byteResult.text,
                            });
                        } else if (mode === ModeByte.Kanji) {
                            var kanjiResult = decodeKanji(stream, size);
                            result.text += kanjiResult.text;
                            (_d = result.bytes).push.apply(
                                _d,
                                kanjiResult.bytes
                            );
                            result.chunks.push({
                                type: Mode.Kanji,
                                bytes: kanjiResult.bytes,
                                text: kanjiResult.text,
                            });
                        }
                    }
                    // If there is no data left, or the remaining bits are all 0, then that counts as a termination marker
                    if (
                        stream.available() === 0 ||
                        stream.readBits(stream.available()) === 0
                    ) {
                        return result;
                    }
                }
                exports.decode = decode;

                /***/
            },
            /* 7 */
            /***/ function (module, exports, __webpack_require__) {
                "use strict";

                // tslint:disable:no-bitwise
                Object.defineProperty(exports, "__esModule", { value: true });
                var BitStream = /** @class */ (function () {
                    function BitStream(bytes) {
                        this.byteOffset = 0;
                        this.bitOffset = 0;
                        this.bytes = bytes;
                    }
                    BitStream.prototype.readBits = function (numBits) {
                        if (
                            numBits < 1 ||
                            numBits > 32 ||
                            numBits > this.available()
                        ) {
                            throw new Error(
                                "Cannot read " + numBits.toString() + " bits"
                            );
                        }
                        var result = 0;
                        // First, read remainder from current byte
                        if (this.bitOffset > 0) {
                            var bitsLeft = 8 - this.bitOffset;
                            var toRead =
                                numBits < bitsLeft ? numBits : bitsLeft;
                            var bitsToNotRead = bitsLeft - toRead;
                            var mask = (0xff >> (8 - toRead)) << bitsToNotRead;
                            result =
                                (this.bytes[this.byteOffset] & mask) >>
                                bitsToNotRead;
                            numBits -= toRead;
                            this.bitOffset += toRead;
                            if (this.bitOffset === 8) {
                                this.bitOffset = 0;
                                this.byteOffset++;
                            }
                        }
                        // Next read whole bytes
                        if (numBits > 0) {
                            while (numBits >= 8) {
                                result =
                                    (result << 8) |
                                    (this.bytes[this.byteOffset] & 0xff);
                                this.byteOffset++;
                                numBits -= 8;
                            }
                            // Finally read a partial byte
                            if (numBits > 0) {
                                var bitsToNotRead = 8 - numBits;
                                var mask =
                                    (0xff >> bitsToNotRead) << bitsToNotRead;
                                result =
                                    (result << numBits) |
                                    ((this.bytes[this.byteOffset] & mask) >>
                                        bitsToNotRead);
                                this.bitOffset += numBits;
                            }
                        }
                        return result;
                    };
                    BitStream.prototype.available = function () {
                        return (
                            8 * (this.bytes.length - this.byteOffset) -
                            this.bitOffset
                        );
                    };
                    return BitStream;
                })();
                exports.BitStream = BitStream;

                /***/
            },
            /* 8 */
            /***/ function (module, exports, __webpack_require__) {
                "use strict";

                Object.defineProperty(exports, "__esModule", { value: true });
                exports.shiftJISTable = {
                    0x20: 0x0020,
                    0x21: 0x0021,
                    0x22: 0x0022,
                    0x23: 0x0023,
                    0x24: 0x0024,
                    0x25: 0x0025,
                    0x26: 0x0026,
                    0x27: 0x0027,
                    0x28: 0x0028,
                    0x29: 0x0029,
                    0x2a: 0x002a,
                    0x2b: 0x002b,
                    0x2c: 0x002c,
                    0x2d: 0x002d,
                    0x2e: 0x002e,
                    0x2f: 0x002f,
                    0x30: 0x0030,
                    0x31: 0x0031,
                    0x32: 0x0032,
                    0x33: 0x0033,
                    0x34: 0x0034,
                    0x35: 0x0035,
                    0x36: 0x0036,
                    0x37: 0x0037,
                    0x38: 0x0038,
                    0x39: 0x0039,
                    0x3a: 0x003a,
                    0x3b: 0x003b,
                    0x3c: 0x003c,
                    0x3d: 0x003d,
                    0x3e: 0x003e,
                    0x3f: 0x003f,
                    0x40: 0x0040,
                    0x41: 0x0041,
                    0x42: 0x0042,
                    0x43: 0x0043,
                    0x44: 0x0044,
                    0x45: 0x0045,
                    0x46: 0x0046,
                    0x47: 0x0047,
                    0x48: 0x0048,
                    0x49: 0x0049,
                    0x4a: 0x004a,
                    0x4b: 0x004b,
                    0x4c: 0x004c,
                    0x4d: 0x004d,
                    0x4e: 0x004e,
                    0x4f: 0x004f,
                    0x50: 0x0050,
                    0x51: 0x0051,
                    0x52: 0x0052,
                    0x53: 0x0053,
                    0x54: 0x0054,
                    0x55: 0x0055,
                    0x56: 0x0056,
                    0x57: 0x0057,
                    0x58: 0x0058,
                    0x59: 0x0059,
                    0x5a: 0x005a,
                    0x5b: 0x005b,
                    0x5c: 0x00a5,
                    0x5d: 0x005d,
                    0x5e: 0x005e,
                    0x5f: 0x005f,
                    0x60: 0x0060,
                    0x61: 0x0061,
                    0x62: 0x0062,
                    0x63: 0x0063,
                    0x64: 0x0064,
                    0x65: 0x0065,
                    0x66: 0x0066,
                    0x67: 0x0067,
                    0x68: 0x0068,
                    0x69: 0x0069,
                    0x6a: 0x006a,
                    0x6b: 0x006b,
                    0x6c: 0x006c,
                    0x6d: 0x006d,
                    0x6e: 0x006e,
                    0x6f: 0x006f,
                    0x70: 0x0070,
                    0x71: 0x0071,
                    0x72: 0x0072,
                    0x73: 0x0073,
                    0x74: 0x0074,
                    0x75: 0x0075,
                    0x76: 0x0076,
                    0x77: 0x0077,
                    0x78: 0x0078,
                    0x79: 0x0079,
                    0x7a: 0x007a,
                    0x7b: 0x007b,
                    0x7c: 0x007c,
                    0x7d: 0x007d,
                    0x7e: 0x203e,
                    0x8140: 0x3000,
                    0x8141: 0x3001,
                    0x8142: 0x3002,
                    0x8143: 0xff0c,
                    0x8144: 0xff0e,
                    0x8145: 0x30fb,
                    0x8146: 0xff1a,
                    0x8147: 0xff1b,
                    0x8148: 0xff1f,
                    0x8149: 0xff01,
                    0x814a: 0x309b,
                    0x814b: 0x309c,
                    0x814c: 0x00b4,
                    0x814d: 0xff40,
                    0x814e: 0x00a8,
                    0x814f: 0xff3e,
                    0x8150: 0xffe3,
                    0x8151: 0xff3f,
                    0x8152: 0x30fd,
                    0x8153: 0x30fe,
                    0x8154: 0x309d,
                    0x8155: 0x309e,
                    0x8156: 0x3003,
                    0x8157: 0x4edd,
                    0x8158: 0x3005,
                    0x8159: 0x3006,
                    0x815a: 0x3007,
                    0x815b: 0x30fc,
                    0x815c: 0x2015,
                    0x815d: 0x2010,
                    0x815e: 0xff0f,
                    0x815f: 0x005c,
                    0x8160: 0x301c,
                    0x8161: 0x2016,
                    0x8162: 0xff5c,
                    0x8163: 0x2026,
                    0x8164: 0x2025,
                    0x8165: 0x2018,
                    0x8166: 0x2019,
                    0x8167: 0x201c,
                    0x8168: 0x201d,
                    0x8169: 0xff08,
                    0x816a: 0xff09,
                    0x816b: 0x3014,
                    0x816c: 0x3015,
                    0x816d: 0xff3b,
                    0x816e: 0xff3d,
                    0x816f: 0xff5b,
                    0x8170: 0xff5d,
                    0x8171: 0x3008,
                    0x8172: 0x3009,
                    0x8173: 0x300a,
                    0x8174: 0x300b,
                    0x8175: 0x300c,
                    0x8176: 0x300d,
                    0x8177: 0x300e,
                    0x8178: 0x300f,
                    0x8179: 0x3010,
                    0x817a: 0x3011,
                    0x817b: 0xff0b,
                    0x817c: 0x2212,
                    0x817d: 0x00b1,
                    0x817e: 0x00d7,
                    0x8180: 0x00f7,
                    0x8181: 0xff1d,
                    0x8182: 0x2260,
                    0x8183: 0xff1c,
                    0x8184: 0xff1e,
                    0x8185: 0x2266,
                    0x8186: 0x2267,
                    0x8187: 0x221e,
                    0x8188: 0x2234,
                    0x8189: 0x2642,
                    0x818a: 0x2640,
                    0x818b: 0x00b0,
                    0x818c: 0x2032,
                    0x818d: 0x2033,
                    0x818e: 0x2103,
                    0x818f: 0xffe5,
                    0x8190: 0xff04,
                    0x8191: 0x00a2,
                    0x8192: 0x00a3,
                    0x8193: 0xff05,
                    0x8194: 0xff03,
                    0x8195: 0xff06,
                    0x8196: 0xff0a,
                    0x8197: 0xff20,
                    0x8198: 0x00a7,
                    0x8199: 0x2606,
                    0x819a: 0x2605,
                    0x819b: 0x25cb,
                    0x819c: 0x25cf,
                    0x819d: 0x25ce,
                    0x819e: 0x25c7,
                    0x819f: 0x25c6,
                    0x81a0: 0x25a1,
                    0x81a1: 0x25a0,
                    0x81a2: 0x25b3,
                    0x81a3: 0x25b2,
                    0x81a4: 0x25bd,
                    0x81a5: 0x25bc,
                    0x81a6: 0x203b,
                    0x81a7: 0x3012,
                    0x81a8: 0x2192,
                    0x81a9: 0x2190,
                    0x81aa: 0x2191,
                    0x81ab: 0x2193,
                    0x81ac: 0x3013,
                    0x81b8: 0x2208,
                    0x81b9: 0x220b,
                    0x81ba: 0x2286,
                    0x81bb: 0x2287,
                    0x81bc: 0x2282,
                    0x81bd: 0x2283,
                    0x81be: 0x222a,
                    0x81bf: 0x2229,
                    0x81c8: 0x2227,
                    0x81c9: 0x2228,
                    0x81ca: 0x00ac,
                    0x81cb: 0x21d2,
                    0x81cc: 0x21d4,
                    0x81cd: 0x2200,
                    0x81ce: 0x2203,
                    0x81da: 0x2220,
                    0x81db: 0x22a5,
                    0x81dc: 0x2312,
                    0x81dd: 0x2202,
                    0x81de: 0x2207,
                    0x81df: 0x2261,
                    0x81e0: 0x2252,
                    0x81e1: 0x226a,
                    0x81e2: 0x226b,
                    0x81e3: 0x221a,
                    0x81e4: 0x223d,
                    0x81e5: 0x221d,
                    0x81e6: 0x2235,
                    0x81e7: 0x222b,
                    0x81e8: 0x222c,
                    0x81f0: 0x212b,
                    0x81f1: 0x2030,
                    0x81f2: 0x266f,
                    0x81f3: 0x266d,
                    0x81f4: 0x266a,
                    0x81f5: 0x2020,
                    0x81f6: 0x2021,
                    0x81f7: 0x00b6,
                    0x81fc: 0x25ef,
                    0x824f: 0xff10,
                    0x8250: 0xff11,
                    0x8251: 0xff12,
                    0x8252: 0xff13,
                    0x8253: 0xff14,
                    0x8254: 0xff15,
                    0x8255: 0xff16,
                    0x8256: 0xff17,
                    0x8257: 0xff18,
                    0x8258: 0xff19,
                    0x8260: 0xff21,
                    0x8261: 0xff22,
                    0x8262: 0xff23,
                    0x8263: 0xff24,
                    0x8264: 0xff25,
                    0x8265: 0xff26,
                    0x8266: 0xff27,
                    0x8267: 0xff28,
                    0x8268: 0xff29,
                    0x8269: 0xff2a,
                    0x826a: 0xff2b,
                    0x826b: 0xff2c,
                    0x826c: 0xff2d,
                    0x826d: 0xff2e,
                    0x826e: 0xff2f,
                    0x826f: 0xff30,
                    0x8270: 0xff31,
                    0x8271: 0xff32,
                    0x8272: 0xff33,
                    0x8273: 0xff34,
                    0x8274: 0xff35,
                    0x8275: 0xff36,
                    0x8276: 0xff37,
                    0x8277: 0xff38,
                    0x8278: 0xff39,
                    0x8279: 0xff3a,
                    0x8281: 0xff41,
                    0x8282: 0xff42,
                    0x8283: 0xff43,
                    0x8284: 0xff44,
                    0x8285: 0xff45,
                    0x8286: 0xff46,
                    0x8287: 0xff47,
                    0x8288: 0xff48,
                    0x8289: 0xff49,
                    0x828a: 0xff4a,
                    0x828b: 0xff4b,
                    0x828c: 0xff4c,
                    0x828d: 0xff4d,
                    0x828e: 0xff4e,
                    0x828f: 0xff4f,
                    0x8290: 0xff50,
                    0x8291: 0xff51,
                    0x8292: 0xff52,
                    0x8293: 0xff53,
                    0x8294: 0xff54,
                    0x8295: 0xff55,
                    0x8296: 0xff56,
                    0x8297: 0xff57,
                    0x8298: 0xff58,
                    0x8299: 0xff59,
                    0x829a: 0xff5a,
                    0x829f: 0x3041,
                    0x82a0: 0x3042,
                    0x82a1: 0x3043,
                    0x82a2: 0x3044,
                    0x82a3: 0x3045,
                    0x82a4: 0x3046,
                    0x82a5: 0x3047,
                    0x82a6: 0x3048,
                    0x82a7: 0x3049,
                    0x82a8: 0x304a,
                    0x82a9: 0x304b,
                    0x82aa: 0x304c,
                    0x82ab: 0x304d,
                    0x82ac: 0x304e,
                    0x82ad: 0x304f,
                    0x82ae: 0x3050,
                    0x82af: 0x3051,
                    0x82b0: 0x3052,
                    0x82b1: 0x3053,
                    0x82b2: 0x3054,
                    0x82b3: 0x3055,
                    0x82b4: 0x3056,
                    0x82b5: 0x3057,
                    0x82b6: 0x3058,
                    0x82b7: 0x3059,
                    0x82b8: 0x305a,
                    0x82b9: 0x305b,
                    0x82ba: 0x305c,
                    0x82bb: 0x305d,
                    0x82bc: 0x305e,
                    0x82bd: 0x305f,
                    0x82be: 0x3060,
                    0x82bf: 0x3061,
                    0x82c0: 0x3062,
                    0x82c1: 0x3063,
                    0x82c2: 0x3064,
                    0x82c3: 0x3065,
                    0x82c4: 0x3066,
                    0x82c5: 0x3067,
                    0x82c6: 0x3068,
                    0x82c7: 0x3069,
                    0x82c8: 0x306a,
                    0x82c9: 0x306b,
                    0x82ca: 0x306c,
                    0x82cb: 0x306d,
                    0x82cc: 0x306e,
                    0x82cd: 0x306f,
                    0x82ce: 0x3070,
                    0x82cf: 0x3071,
                    0x82d0: 0x3072,
                    0x82d1: 0x3073,
                    0x82d2: 0x3074,
                    0x82d3: 0x3075,
                    0x82d4: 0x3076,
                    0x82d5: 0x3077,
                    0x82d6: 0x3078,
                    0x82d7: 0x3079,
                    0x82d8: 0x307a,
                    0x82d9: 0x307b,
                    0x82da: 0x307c,
                    0x82db: 0x307d,
                    0x82dc: 0x307e,
                    0x82dd: 0x307f,
                    0x82de: 0x3080,
                    0x82df: 0x3081,
                    0x82e0: 0x3082,
                    0x82e1: 0x3083,
                    0x82e2: 0x3084,
                    0x82e3: 0x3085,
                    0x82e4: 0x3086,
                    0x82e5: 0x3087,
                    0x82e6: 0x3088,
                    0x82e7: 0x3089,
                    0x82e8: 0x308a,
                    0x82e9: 0x308b,
                    0x82ea: 0x308c,
                    0x82eb: 0x308d,
                    0x82ec: 0x308e,
                    0x82ed: 0x308f,
                    0x82ee: 0x3090,
                    0x82ef: 0x3091,
                    0x82f0: 0x3092,
                    0x82f1: 0x3093,
                    0x8340: 0x30a1,
                    0x8341: 0x30a2,
                    0x8342: 0x30a3,
                    0x8343: 0x30a4,
                    0x8344: 0x30a5,
                    0x8345: 0x30a6,
                    0x8346: 0x30a7,
                    0x8347: 0x30a8,
                    0x8348: 0x30a9,
                    0x8349: 0x30aa,
                    0x834a: 0x30ab,
                    0x834b: 0x30ac,
                    0x834c: 0x30ad,
                    0x834d: 0x30ae,
                    0x834e: 0x30af,
                    0x834f: 0x30b0,
                    0x8350: 0x30b1,
                    0x8351: 0x30b2,
                    0x8352: 0x30b3,
                    0x8353: 0x30b4,
                    0x8354: 0x30b5,
                    0x8355: 0x30b6,
                    0x8356: 0x30b7,
                    0x8357: 0x30b8,
                    0x8358: 0x30b9,
                    0x8359: 0x30ba,
                    0x835a: 0x30bb,
                    0x835b: 0x30bc,
                    0x835c: 0x30bd,
                    0x835d: 0x30be,
                    0x835e: 0x30bf,
                    0x835f: 0x30c0,
                    0x8360: 0x30c1,
                    0x8361: 0x30c2,
                    0x8362: 0x30c3,
                    0x8363: 0x30c4,
                    0x8364: 0x30c5,
                    0x8365: 0x30c6,
                    0x8366: 0x30c7,
                    0x8367: 0x30c8,
                    0x8368: 0x30c9,
                    0x8369: 0x30ca,
                    0x836a: 0x30cb,
                    0x836b: 0x30cc,
                    0x836c: 0x30cd,
                    0x836d: 0x30ce,
                    0x836e: 0x30cf,
                    0x836f: 0x30d0,
                    0x8370: 0x30d1,
                    0x8371: 0x30d2,
                    0x8372: 0x30d3,
                    0x8373: 0x30d4,
                    0x8374: 0x30d5,
                    0x8375: 0x30d6,
                    0x8376: 0x30d7,
                    0x8377: 0x30d8,
                    0x8378: 0x30d9,
                    0x8379: 0x30da,
                    0x837a: 0x30db,
                    0x837b: 0x30dc,
                    0x837c: 0x30dd,
                    0x837d: 0x30de,
                    0x837e: 0x30df,
                    0x8380: 0x30e0,
                    0x8381: 0x30e1,
                    0x8382: 0x30e2,
                    0x8383: 0x30e3,
                    0x8384: 0x30e4,
                    0x8385: 0x30e5,
                    0x8386: 0x30e6,
                    0x8387: 0x30e7,
                    0x8388: 0x30e8,
                    0x8389: 0x30e9,
                    0x838a: 0x30ea,
                    0x838b: 0x30eb,
                    0x838c: 0x30ec,
                    0x838d: 0x30ed,
                    0x838e: 0x30ee,
                    0x838f: 0x30ef,
                    0x8390: 0x30f0,
                    0x8391: 0x30f1,
                    0x8392: 0x30f2,
                    0x8393: 0x30f3,
                    0x8394: 0x30f4,
                    0x8395: 0x30f5,
                    0x8396: 0x30f6,
                    0x839f: 0x0391,
                    0x83a0: 0x0392,
                    0x83a1: 0x0393,
                    0x83a2: 0x0394,
                    0x83a3: 0x0395,
                    0x83a4: 0x0396,
                    0x83a5: 0x0397,
                    0x83a6: 0x0398,
                    0x83a7: 0x0399,
                    0x83a8: 0x039a,
                    0x83a9: 0x039b,
                    0x83aa: 0x039c,
                    0x83ab: 0x039d,
                    0x83ac: 0x039e,
                    0x83ad: 0x039f,
                    0x83ae: 0x03a0,
                    0x83af: 0x03a1,
                    0x83b0: 0x03a3,
                    0x83b1: 0x03a4,
                    0x83b2: 0x03a5,
                    0x83b3: 0x03a6,
                    0x83b4: 0x03a7,
                    0x83b5: 0x03a8,
                    0x83b6: 0x03a9,
                    0x83bf: 0x03b1,
                    0x83c0: 0x03b2,
                    0x83c1: 0x03b3,
                    0x83c2: 0x03b4,
                    0x83c3: 0x03b5,
                    0x83c4: 0x03b6,
                    0x83c5: 0x03b7,
                    0x83c6: 0x03b8,
                    0x83c7: 0x03b9,
                    0x83c8: 0x03ba,
                    0x83c9: 0x03bb,
                    0x83ca: 0x03bc,
                    0x83cb: 0x03bd,
                    0x83cc: 0x03be,
                    0x83cd: 0x03bf,
                    0x83ce: 0x03c0,
                    0x83cf: 0x03c1,
                    0x83d0: 0x03c3,
                    0x83d1: 0x03c4,
                    0x83d2: 0x03c5,
                    0x83d3: 0x03c6,
                    0x83d4: 0x03c7,
                    0x83d5: 0x03c8,
                    0x83d6: 0x03c9,
                    0x8440: 0x0410,
                    0x8441: 0x0411,
                    0x8442: 0x0412,
                    0x8443: 0x0413,
                    0x8444: 0x0414,
                    0x8445: 0x0415,
                    0x8446: 0x0401,
                    0x8447: 0x0416,
                    0x8448: 0x0417,
                    0x8449: 0x0418,
                    0x844a: 0x0419,
                    0x844b: 0x041a,
                    0x844c: 0x041b,
                    0x844d: 0x041c,
                    0x844e: 0x041d,
                    0x844f: 0x041e,
                    0x8450: 0x041f,
                    0x8451: 0x0420,
                    0x8452: 0x0421,
                    0x8453: 0x0422,
                    0x8454: 0x0423,
                    0x8455: 0x0424,
                    0x8456: 0x0425,
                    0x8457: 0x0426,
                    0x8458: 0x0427,
                    0x8459: 0x0428,
                    0x845a: 0x0429,
                    0x845b: 0x042a,
                    0x845c: 0x042b,
                    0x845d: 0x042c,
                    0x845e: 0x042d,
                    0x845f: 0x042e,
                    0x8460: 0x042f,
                    0x8470: 0x0430,
                    0x8471: 0x0431,
                    0x8472: 0x0432,
                    0x8473: 0x0433,
                    0x8474: 0x0434,
                    0x8475: 0x0435,
                    0x8476: 0x0451,
                    0x8477: 0x0436,
                    0x8478: 0x0437,
                    0x8479: 0x0438,
                    0x847a: 0x0439,
                    0x847b: 0x043a,
                    0x847c: 0x043b,
                    0x847d: 0x043c,
                    0x847e: 0x043d,
                    0x8480: 0x043e,
                    0x8481: 0x043f,
                    0x8482: 0x0440,
                    0x8483: 0x0441,
                    0x8484: 0x0442,
                    0x8485: 0x0443,
                    0x8486: 0x0444,
                    0x8487: 0x0445,
                    0x8488: 0x0446,
                    0x8489: 0x0447,
                    0x848a: 0x0448,
                    0x848b: 0x0449,
                    0x848c: 0x044a,
                    0x848d: 0x044b,
                    0x848e: 0x044c,
                    0x848f: 0x044d,
                    0x8490: 0x044e,
                    0x8491: 0x044f,
                    0x849f: 0x2500,
                    0x84a0: 0x2502,
                    0x84a1: 0x250c,
                    0x84a2: 0x2510,
                    0x84a3: 0x2518,
                    0x84a4: 0x2514,
                    0x84a5: 0x251c,
                    0x84a6: 0x252c,
                    0x84a7: 0x2524,
                    0x84a8: 0x2534,
                    0x84a9: 0x253c,
                    0x84aa: 0x2501,
                    0x84ab: 0x2503,
                    0x84ac: 0x250f,
                    0x84ad: 0x2513,
                    0x84ae: 0x251b,
                    0x84af: 0x2517,
                    0x84b0: 0x2523,
                    0x84b1: 0x2533,
                    0x84b2: 0x252b,
                    0x84b3: 0x253b,
                    0x84b4: 0x254b,
                    0x84b5: 0x2520,
                    0x84b6: 0x252f,
                    0x84b7: 0x2528,
                    0x84b8: 0x2537,
                    0x84b9: 0x253f,
                    0x84ba: 0x251d,
                    0x84bb: 0x2530,
                    0x84bc: 0x2525,
                    0x84bd: 0x2538,
                    0x84be: 0x2542,
                    0x889f: 0x4e9c,
                    0x88a0: 0x5516,
                    0x88a1: 0x5a03,
                    0x88a2: 0x963f,
                    0x88a3: 0x54c0,
                    0x88a4: 0x611b,
                    0x88a5: 0x6328,
                    0x88a6: 0x59f6,
                    0x88a7: 0x9022,
                    0x88a8: 0x8475,
                    0x88a9: 0x831c,
                    0x88aa: 0x7a50,
                    0x88ab: 0x60aa,
                    0x88ac: 0x63e1,
                    0x88ad: 0x6e25,
                    0x88ae: 0x65ed,
                    0x88af: 0x8466,
                    0x88b0: 0x82a6,
                    0x88b1: 0x9bf5,
                    0x88b2: 0x6893,
                    0x88b3: 0x5727,
                    0x88b4: 0x65a1,
                    0x88b5: 0x6271,
                    0x88b6: 0x5b9b,
                    0x88b7: 0x59d0,
                    0x88b8: 0x867b,
                    0x88b9: 0x98f4,
                    0x88ba: 0x7d62,
                    0x88bb: 0x7dbe,
                    0x88bc: 0x9b8e,
                    0x88bd: 0x6216,
                    0x88be: 0x7c9f,
                    0x88bf: 0x88b7,
                    0x88c0: 0x5b89,
                    0x88c1: 0x5eb5,
                    0x88c2: 0x6309,
                    0x88c3: 0x6697,
                    0x88c4: 0x6848,
                    0x88c5: 0x95c7,
                    0x88c6: 0x978d,
                    0x88c7: 0x674f,
                    0x88c8: 0x4ee5,
                    0x88c9: 0x4f0a,
                    0x88ca: 0x4f4d,
                    0x88cb: 0x4f9d,
                    0x88cc: 0x5049,
                    0x88cd: 0x56f2,
                    0x88ce: 0x5937,
                    0x88cf: 0x59d4,
                    0x88d0: 0x5a01,
                    0x88d1: 0x5c09,
                    0x88d2: 0x60df,
                    0x88d3: 0x610f,
                    0x88d4: 0x6170,
                    0x88d5: 0x6613,
                    0x88d6: 0x6905,
                    0x88d7: 0x70ba,
                    0x88d8: 0x754f,
                    0x88d9: 0x7570,
                    0x88da: 0x79fb,
                    0x88db: 0x7dad,
                    0x88dc: 0x7def,
                    0x88dd: 0x80c3,
                    0x88de: 0x840e,
                    0x88df: 0x8863,
                    0x88e0: 0x8b02,
                    0x88e1: 0x9055,
                    0x88e2: 0x907a,
                    0x88e3: 0x533b,
                    0x88e4: 0x4e95,
                    0x88e5: 0x4ea5,
                    0x88e6: 0x57df,
                    0x88e7: 0x80b2,
                    0x88e8: 0x90c1,
                    0x88e9: 0x78ef,
                    0x88ea: 0x4e00,
                    0x88eb: 0x58f1,
                    0x88ec: 0x6ea2,
                    0x88ed: 0x9038,
                    0x88ee: 0x7a32,
                    0x88ef: 0x8328,
                    0x88f0: 0x828b,
                    0x88f1: 0x9c2f,
                    0x88f2: 0x5141,
                    0x88f3: 0x5370,
                    0x88f4: 0x54bd,
                    0x88f5: 0x54e1,
                    0x88f6: 0x56e0,
                    0x88f7: 0x59fb,
                    0x88f8: 0x5f15,
                    0x88f9: 0x98f2,
                    0x88fa: 0x6deb,
                    0x88fb: 0x80e4,
                    0x88fc: 0x852d,
                    0x8940: 0x9662,
                    0x8941: 0x9670,
                    0x8942: 0x96a0,
                    0x8943: 0x97fb,
                    0x8944: 0x540b,
                    0x8945: 0x53f3,
                    0x8946: 0x5b87,
                    0x8947: 0x70cf,
                    0x8948: 0x7fbd,
                    0x8949: 0x8fc2,
                    0x894a: 0x96e8,
                    0x894b: 0x536f,
                    0x894c: 0x9d5c,
                    0x894d: 0x7aba,
                    0x894e: 0x4e11,
                    0x894f: 0x7893,
                    0x8950: 0x81fc,
                    0x8951: 0x6e26,
                    0x8952: 0x5618,
                    0x8953: 0x5504,
                    0x8954: 0x6b1d,
                    0x8955: 0x851a,
                    0x8956: 0x9c3b,
                    0x8957: 0x59e5,
                    0x8958: 0x53a9,
                    0x8959: 0x6d66,
                    0x895a: 0x74dc,
                    0x895b: 0x958f,
                    0x895c: 0x5642,
                    0x895d: 0x4e91,
                    0x895e: 0x904b,
                    0x895f: 0x96f2,
                    0x8960: 0x834f,
                    0x8961: 0x990c,
                    0x8962: 0x53e1,
                    0x8963: 0x55b6,
                    0x8964: 0x5b30,
                    0x8965: 0x5f71,
                    0x8966: 0x6620,
                    0x8967: 0x66f3,
                    0x8968: 0x6804,
                    0x8969: 0x6c38,
                    0x896a: 0x6cf3,
                    0x896b: 0x6d29,
                    0x896c: 0x745b,
                    0x896d: 0x76c8,
                    0x896e: 0x7a4e,
                    0x896f: 0x9834,
                    0x8970: 0x82f1,
                    0x8971: 0x885b,
                    0x8972: 0x8a60,
                    0x8973: 0x92ed,
                    0x8974: 0x6db2,
                    0x8975: 0x75ab,
                    0x8976: 0x76ca,
                    0x8977: 0x99c5,
                    0x8978: 0x60a6,
                    0x8979: 0x8b01,
                    0x897a: 0x8d8a,
                    0x897b: 0x95b2,
                    0x897c: 0x698e,
                    0x897d: 0x53ad,
                    0x897e: 0x5186,
                    0x8980: 0x5712,
                    0x8981: 0x5830,
                    0x8982: 0x5944,
                    0x8983: 0x5bb4,
                    0x8984: 0x5ef6,
                    0x8985: 0x6028,
                    0x8986: 0x63a9,
                    0x8987: 0x63f4,
                    0x8988: 0x6cbf,
                    0x8989: 0x6f14,
                    0x898a: 0x708e,
                    0x898b: 0x7114,
                    0x898c: 0x7159,
                    0x898d: 0x71d5,
                    0x898e: 0x733f,
                    0x898f: 0x7e01,
                    0x8990: 0x8276,
                    0x8991: 0x82d1,
                    0x8992: 0x8597,
                    0x8993: 0x9060,
                    0x8994: 0x925b,
                    0x8995: 0x9d1b,
                    0x8996: 0x5869,
                    0x8997: 0x65bc,
                    0x8998: 0x6c5a,
                    0x8999: 0x7525,
                    0x899a: 0x51f9,
                    0x899b: 0x592e,
                    0x899c: 0x5965,
                    0x899d: 0x5f80,
                    0x899e: 0x5fdc,
                    0x899f: 0x62bc,
                    0x89a0: 0x65fa,
                    0x89a1: 0x6a2a,
                    0x89a2: 0x6b27,
                    0x89a3: 0x6bb4,
                    0x89a4: 0x738b,
                    0x89a5: 0x7fc1,
                    0x89a6: 0x8956,
                    0x89a7: 0x9d2c,
                    0x89a8: 0x9d0e,
                    0x89a9: 0x9ec4,
                    0x89aa: 0x5ca1,
                    0x89ab: 0x6c96,
                    0x89ac: 0x837b,
                    0x89ad: 0x5104,
                    0x89ae: 0x5c4b,
                    0x89af: 0x61b6,
                    0x89b0: 0x81c6,
                    0x89b1: 0x6876,
                    0x89b2: 0x7261,
                    0x89b3: 0x4e59,
                    0x89b4: 0x4ffa,
                    0x89b5: 0x5378,
                    0x89b6: 0x6069,
                    0x89b7: 0x6e29,
                    0x89b8: 0x7a4f,
                    0x89b9: 0x97f3,
                    0x89ba: 0x4e0b,
                    0x89bb: 0x5316,
                    0x89bc: 0x4eee,
                    0x89bd: 0x4f55,
                    0x89be: 0x4f3d,
                    0x89bf: 0x4fa1,
                    0x89c0: 0x4f73,
                    0x89c1: 0x52a0,
                    0x89c2: 0x53ef,
                    0x89c3: 0x5609,
                    0x89c4: 0x590f,
                    0x89c5: 0x5ac1,
                    0x89c6: 0x5bb6,
                    0x89c7: 0x5be1,
                    0x89c8: 0x79d1,
                    0x89c9: 0x6687,
                    0x89ca: 0x679c,
                    0x89cb: 0x67b6,
                    0x89cc: 0x6b4c,
                    0x89cd: 0x6cb3,
                    0x89ce: 0x706b,
                    0x89cf: 0x73c2,
                    0x89d0: 0x798d,
                    0x89d1: 0x79be,
                    0x89d2: 0x7a3c,
                    0x89d3: 0x7b87,
                    0x89d4: 0x82b1,
                    0x89d5: 0x82db,
                    0x89d6: 0x8304,
                    0x89d7: 0x8377,
                    0x89d8: 0x83ef,
                    0x89d9: 0x83d3,
                    0x89da: 0x8766,
                    0x89db: 0x8ab2,
                    0x89dc: 0x5629,
                    0x89dd: 0x8ca8,
                    0x89de: 0x8fe6,
                    0x89df: 0x904e,
                    0x89e0: 0x971e,
                    0x89e1: 0x868a,
                    0x89e2: 0x4fc4,
                    0x89e3: 0x5ce8,
                    0x89e4: 0x6211,
                    0x89e5: 0x7259,
                    0x89e6: 0x753b,
                    0x89e7: 0x81e5,
                    0x89e8: 0x82bd,
                    0x89e9: 0x86fe,
                    0x89ea: 0x8cc0,
                    0x89eb: 0x96c5,
                    0x89ec: 0x9913,
                    0x89ed: 0x99d5,
                    0x89ee: 0x4ecb,
                    0x89ef: 0x4f1a,
                    0x89f0: 0x89e3,
                    0x89f1: 0x56de,
                    0x89f2: 0x584a,
                    0x89f3: 0x58ca,
                    0x89f4: 0x5efb,
                    0x89f5: 0x5feb,
                    0x89f6: 0x602a,
                    0x89f7: 0x6094,
                    0x89f8: 0x6062,
                    0x89f9: 0x61d0,
                    0x89fa: 0x6212,
                    0x89fb: 0x62d0,
                    0x89fc: 0x6539,
                    0x8a40: 0x9b41,
                    0x8a41: 0x6666,
                    0x8a42: 0x68b0,
                    0x8a43: 0x6d77,
                    0x8a44: 0x7070,
                    0x8a45: 0x754c,
                    0x8a46: 0x7686,
                    0x8a47: 0x7d75,
                    0x8a48: 0x82a5,
                    0x8a49: 0x87f9,
                    0x8a4a: 0x958b,
                    0x8a4b: 0x968e,
                    0x8a4c: 0x8c9d,
                    0x8a4d: 0x51f1,
                    0x8a4e: 0x52be,
                    0x8a4f: 0x5916,
                    0x8a50: 0x54b3,
                    0x8a51: 0x5bb3,
                    0x8a52: 0x5d16,
                    0x8a53: 0x6168,
                    0x8a54: 0x6982,
                    0x8a55: 0x6daf,
                    0x8a56: 0x788d,
                    0x8a57: 0x84cb,
                    0x8a58: 0x8857,
                    0x8a59: 0x8a72,
                    0x8a5a: 0x93a7,
                    0x8a5b: 0x9ab8,
                    0x8a5c: 0x6d6c,
                    0x8a5d: 0x99a8,
                    0x8a5e: 0x86d9,
                    0x8a5f: 0x57a3,
                    0x8a60: 0x67ff,
                    0x8a61: 0x86ce,
                    0x8a62: 0x920e,
                    0x8a63: 0x5283,
                    0x8a64: 0x5687,
                    0x8a65: 0x5404,
                    0x8a66: 0x5ed3,
                    0x8a67: 0x62e1,
                    0x8a68: 0x64b9,
                    0x8a69: 0x683c,
                    0x8a6a: 0x6838,
                    0x8a6b: 0x6bbb,
                    0x8a6c: 0x7372,
                    0x8a6d: 0x78ba,
                    0x8a6e: 0x7a6b,
                    0x8a6f: 0x899a,
                    0x8a70: 0x89d2,
                    0x8a71: 0x8d6b,
                    0x8a72: 0x8f03,
                    0x8a73: 0x90ed,
                    0x8a74: 0x95a3,
                    0x8a75: 0x9694,
                    0x8a76: 0x9769,
                    0x8a77: 0x5b66,
                    0x8a78: 0x5cb3,
                    0x8a79: 0x697d,
                    0x8a7a: 0x984d,
                    0x8a7b: 0x984e,
                    0x8a7c: 0x639b,
                    0x8a7d: 0x7b20,
                    0x8a7e: 0x6a2b,
                    0x8a80: 0x6a7f,
                    0x8a81: 0x68b6,
                    0x8a82: 0x9c0d,
                    0x8a83: 0x6f5f,
                    0x8a84: 0x5272,
                    0x8a85: 0x559d,
                    0x8a86: 0x6070,
                    0x8a87: 0x62ec,
                    0x8a88: 0x6d3b,
                    0x8a89: 0x6e07,
                    0x8a8a: 0x6ed1,
                    0x8a8b: 0x845b,
                    0x8a8c: 0x8910,
                    0x8a8d: 0x8f44,
                    0x8a8e: 0x4e14,
                    0x8a8f: 0x9c39,
                    0x8a90: 0x53f6,
                    0x8a91: 0x691b,
                    0x8a92: 0x6a3a,
                    0x8a93: 0x9784,
                    0x8a94: 0x682a,
                    0x8a95: 0x515c,
                    0x8a96: 0x7ac3,
                    0x8a97: 0x84b2,
                    0x8a98: 0x91dc,
                    0x8a99: 0x938c,
                    0x8a9a: 0x565b,
                    0x8a9b: 0x9d28,
                    0x8a9c: 0x6822,
                    0x8a9d: 0x8305,
                    0x8a9e: 0x8431,
                    0x8a9f: 0x7ca5,
                    0x8aa0: 0x5208,
                    0x8aa1: 0x82c5,
                    0x8aa2: 0x74e6,
                    0x8aa3: 0x4e7e,
                    0x8aa4: 0x4f83,
                    0x8aa5: 0x51a0,
                    0x8aa6: 0x5bd2,
                    0x8aa7: 0x520a,
                    0x8aa8: 0x52d8,
                    0x8aa9: 0x52e7,
                    0x8aaa: 0x5dfb,
                    0x8aab: 0x559a,
                    0x8aac: 0x582a,
                    0x8aad: 0x59e6,
                    0x8aae: 0x5b8c,
                    0x8aaf: 0x5b98,
                    0x8ab0: 0x5bdb,
                    0x8ab1: 0x5e72,
                    0x8ab2: 0x5e79,
                    0x8ab3: 0x60a3,
                    0x8ab4: 0x611f,
                    0x8ab5: 0x6163,
                    0x8ab6: 0x61be,
                    0x8ab7: 0x63db,
                    0x8ab8: 0x6562,
                    0x8ab9: 0x67d1,
                    0x8aba: 0x6853,
                    0x8abb: 0x68fa,
                    0x8abc: 0x6b3e,
                    0x8abd: 0x6b53,
                    0x8abe: 0x6c57,
                    0x8abf: 0x6f22,
                    0x8ac0: 0x6f97,
                    0x8ac1: 0x6f45,
                    0x8ac2: 0x74b0,
                    0x8ac3: 0x7518,
                    0x8ac4: 0x76e3,
                    0x8ac5: 0x770b,
                    0x8ac6: 0x7aff,
                    0x8ac7: 0x7ba1,
                    0x8ac8: 0x7c21,
                    0x8ac9: 0x7de9,
                    0x8aca: 0x7f36,
                    0x8acb: 0x7ff0,
                    0x8acc: 0x809d,
                    0x8acd: 0x8266,
                    0x8ace: 0x839e,
                    0x8acf: 0x89b3,
                    0x8ad0: 0x8acc,
                    0x8ad1: 0x8cab,
                    0x8ad2: 0x9084,
                    0x8ad3: 0x9451,
                    0x8ad4: 0x9593,
                    0x8ad5: 0x9591,
                    0x8ad6: 0x95a2,
                    0x8ad7: 0x9665,
                    0x8ad8: 0x97d3,
                    0x8ad9: 0x9928,
                    0x8ada: 0x8218,
                    0x8adb: 0x4e38,
                    0x8adc: 0x542b,
                    0x8add: 0x5cb8,
                    0x8ade: 0x5dcc,
                    0x8adf: 0x73a9,
                    0x8ae0: 0x764c,
                    0x8ae1: 0x773c,
                    0x8ae2: 0x5ca9,
                    0x8ae3: 0x7feb,
                    0x8ae4: 0x8d0b,
                    0x8ae5: 0x96c1,
                    0x8ae6: 0x9811,
                    0x8ae7: 0x9854,
                    0x8ae8: 0x9858,
                    0x8ae9: 0x4f01,
                    0x8aea: 0x4f0e,
                    0x8aeb: 0x5371,
                    0x8aec: 0x559c,
                    0x8aed: 0x5668,
                    0x8aee: 0x57fa,
                    0x8aef: 0x5947,
                    0x8af0: 0x5b09,
                    0x8af1: 0x5bc4,
                    0x8af2: 0x5c90,
                    0x8af3: 0x5e0c,
                    0x8af4: 0x5e7e,
                    0x8af5: 0x5fcc,
                    0x8af6: 0x63ee,
                    0x8af7: 0x673a,
                    0x8af8: 0x65d7,
                    0x8af9: 0x65e2,
                    0x8afa: 0x671f,
                    0x8afb: 0x68cb,
                    0x8afc: 0x68c4,
                    0x8b40: 0x6a5f,
                    0x8b41: 0x5e30,
                    0x8b42: 0x6bc5,
                    0x8b43: 0x6c17,
                    0x8b44: 0x6c7d,
                    0x8b45: 0x757f,
                    0x8b46: 0x7948,
                    0x8b47: 0x5b63,
                    0x8b48: 0x7a00,
                    0x8b49: 0x7d00,
                    0x8b4a: 0x5fbd,
                    0x8b4b: 0x898f,
                    0x8b4c: 0x8a18,
                    0x8b4d: 0x8cb4,
                    0x8b4e: 0x8d77,
                    0x8b4f: 0x8ecc,
                    0x8b50: 0x8f1d,
                    0x8b51: 0x98e2,
                    0x8b52: 0x9a0e,
                    0x8b53: 0x9b3c,
                    0x8b54: 0x4e80,
                    0x8b55: 0x507d,
                    0x8b56: 0x5100,
                    0x8b57: 0x5993,
                    0x8b58: 0x5b9c,
                    0x8b59: 0x622f,
                    0x8b5a: 0x6280,
                    0x8b5b: 0x64ec,
                    0x8b5c: 0x6b3a,
                    0x8b5d: 0x72a0,
                    0x8b5e: 0x7591,
                    0x8b5f: 0x7947,
                    0x8b60: 0x7fa9,
                    0x8b61: 0x87fb,
                    0x8b62: 0x8abc,
                    0x8b63: 0x8b70,
                    0x8b64: 0x63ac,
                    0x8b65: 0x83ca,
                    0x8b66: 0x97a0,
                    0x8b67: 0x5409,
                    0x8b68: 0x5403,
                    0x8b69: 0x55ab,
                    0x8b6a: 0x6854,
                    0x8b6b: 0x6a58,
                    0x8b6c: 0x8a70,
                    0x8b6d: 0x7827,
                    0x8b6e: 0x6775,
                    0x8b6f: 0x9ecd,
                    0x8b70: 0x5374,
                    0x8b71: 0x5ba2,
                    0x8b72: 0x811a,
                    0x8b73: 0x8650,
                    0x8b74: 0x9006,
                    0x8b75: 0x4e18,
                    0x8b76: 0x4e45,
                    0x8b77: 0x4ec7,
                    0x8b78: 0x4f11,
                    0x8b79: 0x53ca,
                    0x8b7a: 0x5438,
                    0x8b7b: 0x5bae,
                    0x8b7c: 0x5f13,
                    0x8b7d: 0x6025,
                    0x8b7e: 0x6551,
                    0x8b80: 0x673d,
                    0x8b81: 0x6c42,
                    0x8b82: 0x6c72,
                    0x8b83: 0x6ce3,
                    0x8b84: 0x7078,
                    0x8b85: 0x7403,
                    0x8b86: 0x7a76,
                    0x8b87: 0x7aae,
                    0x8b88: 0x7b08,
                    0x8b89: 0x7d1a,
                    0x8b8a: 0x7cfe,
                    0x8b8b: 0x7d66,
                    0x8b8c: 0x65e7,
                    0x8b8d: 0x725b,
                    0x8b8e: 0x53bb,
                    0x8b8f: 0x5c45,
                    0x8b90: 0x5de8,
                    0x8b91: 0x62d2,
                    0x8b92: 0x62e0,
                    0x8b93: 0x6319,
                    0x8b94: 0x6e20,
                    0x8b95: 0x865a,
                    0x8b96: 0x8a31,
                    0x8b97: 0x8ddd,
                    0x8b98: 0x92f8,
                    0x8b99: 0x6f01,
                    0x8b9a: 0x79a6,
                    0x8b9b: 0x9b5a,
                    0x8b9c: 0x4ea8,
                    0x8b9d: 0x4eab,
                    0x8b9e: 0x4eac,
                    0x8b9f: 0x4f9b,
                    0x8ba0: 0x4fa0,
                    0x8ba1: 0x50d1,
                    0x8ba2: 0x5147,
                    0x8ba3: 0x7af6,
                    0x8ba4: 0x5171,
                    0x8ba5: 0x51f6,
                    0x8ba6: 0x5354,
                    0x8ba7: 0x5321,
                    0x8ba8: 0x537f,
                    0x8ba9: 0x53eb,
                    0x8baa: 0x55ac,
                    0x8bab: 0x5883,
                    0x8bac: 0x5ce1,
                    0x8bad: 0x5f37,
                    0x8bae: 0x5f4a,
                    0x8baf: 0x602f,
                    0x8bb0: 0x6050,
                    0x8bb1: 0x606d,
                    0x8bb2: 0x631f,
                    0x8bb3: 0x6559,
                    0x8bb4: 0x6a4b,
                    0x8bb5: 0x6cc1,
                    0x8bb6: 0x72c2,
                    0x8bb7: 0x72ed,
                    0x8bb8: 0x77ef,
                    0x8bb9: 0x80f8,
                    0x8bba: 0x8105,
                    0x8bbb: 0x8208,
                    0x8bbc: 0x854e,
                    0x8bbd: 0x90f7,
                    0x8bbe: 0x93e1,
                    0x8bbf: 0x97ff,
                    0x8bc0: 0x9957,
                    0x8bc1: 0x9a5a,
                    0x8bc2: 0x4ef0,
                    0x8bc3: 0x51dd,
                    0x8bc4: 0x5c2d,
                    0x8bc5: 0x6681,
                    0x8bc6: 0x696d,
                    0x8bc7: 0x5c40,
                    0x8bc8: 0x66f2,
                    0x8bc9: 0x6975,
                    0x8bca: 0x7389,
                    0x8bcb: 0x6850,
                    0x8bcc: 0x7c81,
                    0x8bcd: 0x50c5,
                    0x8bce: 0x52e4,
                    0x8bcf: 0x5747,
                    0x8bd0: 0x5dfe,
                    0x8bd1: 0x9326,
                    0x8bd2: 0x65a4,
                    0x8bd3: 0x6b23,
                    0x8bd4: 0x6b3d,
                    0x8bd5: 0x7434,
                    0x8bd6: 0x7981,
                    0x8bd7: 0x79bd,
                    0x8bd8: 0x7b4b,
                    0x8bd9: 0x7dca,
                    0x8bda: 0x82b9,
                    0x8bdb: 0x83cc,
                    0x8bdc: 0x887f,
                    0x8bdd: 0x895f,
                    0x8bde: 0x8b39,
                    0x8bdf: 0x8fd1,
                    0x8be0: 0x91d1,
                    0x8be1: 0x541f,
                    0x8be2: 0x9280,
                    0x8be3: 0x4e5d,
                    0x8be4: 0x5036,
                    0x8be5: 0x53e5,
                    0x8be6: 0x533a,
                    0x8be7: 0x72d7,
                    0x8be8: 0x7396,
                    0x8be9: 0x77e9,
                    0x8bea: 0x82e6,
                    0x8beb: 0x8eaf,
                    0x8bec: 0x99c6,
                    0x8bed: 0x99c8,
                    0x8bee: 0x99d2,
                    0x8bef: 0x5177,
                    0x8bf0: 0x611a,
                    0x8bf1: 0x865e,
                    0x8bf2: 0x55b0,
                    0x8bf3: 0x7a7a,
                    0x8bf4: 0x5076,
                    0x8bf5: 0x5bd3,
                    0x8bf6: 0x9047,
                    0x8bf7: 0x9685,
                    0x8bf8: 0x4e32,
                    0x8bf9: 0x6adb,
                    0x8bfa: 0x91e7,
                    0x8bfb: 0x5c51,
                    0x8bfc: 0x5c48,
                    0x8c40: 0x6398,
                    0x8c41: 0x7a9f,
                    0x8c42: 0x6c93,
                    0x8c43: 0x9774,
                    0x8c44: 0x8f61,
                    0x8c45: 0x7aaa,
                    0x8c46: 0x718a,
                    0x8c47: 0x9688,
                    0x8c48: 0x7c82,
                    0x8c49: 0x6817,
                    0x8c4a: 0x7e70,
                    0x8c4b: 0x6851,
                    0x8c4c: 0x936c,
                    0x8c4d: 0x52f2,
                    0x8c4e: 0x541b,
                    0x8c4f: 0x85ab,
                    0x8c50: 0x8a13,
                    0x8c51: 0x7fa4,
                    0x8c52: 0x8ecd,
                    0x8c53: 0x90e1,
                    0x8c54: 0x5366,
                    0x8c55: 0x8888,
                    0x8c56: 0x7941,
                    0x8c57: 0x4fc2,
                    0x8c58: 0x50be,
                    0x8c59: 0x5211,
                    0x8c5a: 0x5144,
                    0x8c5b: 0x5553,
                    0x8c5c: 0x572d,
                    0x8c5d: 0x73ea,
                    0x8c5e: 0x578b,
                    0x8c5f: 0x5951,
                    0x8c60: 0x5f62,
                    0x8c61: 0x5f84,
                    0x8c62: 0x6075,
                    0x8c63: 0x6176,
                    0x8c64: 0x6167,
                    0x8c65: 0x61a9,
                    0x8c66: 0x63b2,
                    0x8c67: 0x643a,
                    0x8c68: 0x656c,
                    0x8c69: 0x666f,
                    0x8c6a: 0x6842,
                    0x8c6b: 0x6e13,
                    0x8c6c: 0x7566,
                    0x8c6d: 0x7a3d,
                    0x8c6e: 0x7cfb,
                    0x8c6f: 0x7d4c,
                    0x8c70: 0x7d99,
                    0x8c71: 0x7e4b,
                    0x8c72: 0x7f6b,
                    0x8c73: 0x830e,
                    0x8c74: 0x834a,
                    0x8c75: 0x86cd,
                    0x8c76: 0x8a08,
                    0x8c77: 0x8a63,
                    0x8c78: 0x8b66,
                    0x8c79: 0x8efd,
                    0x8c7a: 0x981a,
                    0x8c7b: 0x9d8f,
                    0x8c7c: 0x82b8,
                    0x8c7d: 0x8fce,
                    0x8c7e: 0x9be8,
                    0x8c80: 0x5287,
                    0x8c81: 0x621f,
                    0x8c82: 0x6483,
                    0x8c83: 0x6fc0,
                    0x8c84: 0x9699,
                    0x8c85: 0x6841,
                    0x8c86: 0x5091,
                    0x8c87: 0x6b20,
                    0x8c88: 0x6c7a,
                    0x8c89: 0x6f54,
                    0x8c8a: 0x7a74,
                    0x8c8b: 0x7d50,
                    0x8c8c: 0x8840,
                    0x8c8d: 0x8a23,
                    0x8c8e: 0x6708,
                    0x8c8f: 0x4ef6,
                    0x8c90: 0x5039,
                    0x8c91: 0x5026,
                    0x8c92: 0x5065,
                    0x8c93: 0x517c,
                    0x8c94: 0x5238,
                    0x8c95: 0x5263,
                    0x8c96: 0x55a7,
                    0x8c97: 0x570f,
                    0x8c98: 0x5805,
                    0x8c99: 0x5acc,
                    0x8c9a: 0x5efa,
                    0x8c9b: 0x61b2,
                    0x8c9c: 0x61f8,
                    0x8c9d: 0x62f3,
                    0x8c9e: 0x6372,
                    0x8c9f: 0x691c,
                    0x8ca0: 0x6a29,
                    0x8ca1: 0x727d,
                    0x8ca2: 0x72ac,
                    0x8ca3: 0x732e,
                    0x8ca4: 0x7814,
                    0x8ca5: 0x786f,
                    0x8ca6: 0x7d79,
                    0x8ca7: 0x770c,
                    0x8ca8: 0x80a9,
                    0x8ca9: 0x898b,
                    0x8caa: 0x8b19,
                    0x8cab: 0x8ce2,
                    0x8cac: 0x8ed2,
                    0x8cad: 0x9063,
                    0x8cae: 0x9375,
                    0x8caf: 0x967a,
                    0x8cb0: 0x9855,
                    0x8cb1: 0x9a13,
                    0x8cb2: 0x9e78,
                    0x8cb3: 0x5143,
                    0x8cb4: 0x539f,
                    0x8cb5: 0x53b3,
                    0x8cb6: 0x5e7b,
                    0x8cb7: 0x5f26,
                    0x8cb8: 0x6e1b,
                    0x8cb9: 0x6e90,
                    0x8cba: 0x7384,
                    0x8cbb: 0x73fe,
                    0x8cbc: 0x7d43,
                    0x8cbd: 0x8237,
                    0x8cbe: 0x8a00,
                    0x8cbf: 0x8afa,
                    0x8cc0: 0x9650,
                    0x8cc1: 0x4e4e,
                    0x8cc2: 0x500b,
                    0x8cc3: 0x53e4,
                    0x8cc4: 0x547c,
                    0x8cc5: 0x56fa,
                    0x8cc6: 0x59d1,
                    0x8cc7: 0x5b64,
                    0x8cc8: 0x5df1,
                    0x8cc9: 0x5eab,
                    0x8cca: 0x5f27,
                    0x8ccb: 0x6238,
                    0x8ccc: 0x6545,
                    0x8ccd: 0x67af,
                    0x8cce: 0x6e56,
                    0x8ccf: 0x72d0,
                    0x8cd0: 0x7cca,
                    0x8cd1: 0x88b4,
                    0x8cd2: 0x80a1,
                    0x8cd3: 0x80e1,
                    0x8cd4: 0x83f0,
                    0x8cd5: 0x864e,
                    0x8cd6: 0x8a87,
                    0x8cd7: 0x8de8,
                    0x8cd8: 0x9237,
                    0x8cd9: 0x96c7,
                    0x8cda: 0x9867,
                    0x8cdb: 0x9f13,
                    0x8cdc: 0x4e94,
                    0x8cdd: 0x4e92,
                    0x8cde: 0x4f0d,
                    0x8cdf: 0x5348,
                    0x8ce0: 0x5449,
                    0x8ce1: 0x543e,
                    0x8ce2: 0x5a2f,
                    0x8ce3: 0x5f8c,
                    0x8ce4: 0x5fa1,
                    0x8ce5: 0x609f,
                    0x8ce6: 0x68a7,
                    0x8ce7: 0x6a8e,
                    0x8ce8: 0x745a,
                    0x8ce9: 0x7881,
                    0x8cea: 0x8a9e,
                    0x8ceb: 0x8aa4,
                    0x8cec: 0x8b77,
                    0x8ced: 0x9190,
                    0x8cee: 0x4e5e,
                    0x8cef: 0x9bc9,
                    0x8cf0: 0x4ea4,
                    0x8cf1: 0x4f7c,
                    0x8cf2: 0x4faf,
                    0x8cf3: 0x5019,
                    0x8cf4: 0x5016,
                    0x8cf5: 0x5149,
                    0x8cf6: 0x516c,
                    0x8cf7: 0x529f,
                    0x8cf8: 0x52b9,
                    0x8cf9: 0x52fe,
                    0x8cfa: 0x539a,
                    0x8cfb: 0x53e3,
                    0x8cfc: 0x5411,
                    0x8d40: 0x540e,
                    0x8d41: 0x5589,
                    0x8d42: 0x5751,
                    0x8d43: 0x57a2,
                    0x8d44: 0x597d,
                    0x8d45: 0x5b54,
                    0x8d46: 0x5b5d,
                    0x8d47: 0x5b8f,
                    0x8d48: 0x5de5,
                    0x8d49: 0x5de7,
                    0x8d4a: 0x5df7,
                    0x8d4b: 0x5e78,
                    0x8d4c: 0x5e83,
                    0x8d4d: 0x5e9a,
                    0x8d4e: 0x5eb7,
                    0x8d4f: 0x5f18,
                    0x8d50: 0x6052,
                    0x8d51: 0x614c,
                    0x8d52: 0x6297,
                    0x8d53: 0x62d8,
                    0x8d54: 0x63a7,
                    0x8d55: 0x653b,
                    0x8d56: 0x6602,
                    0x8d57: 0x6643,
                    0x8d58: 0x66f4,
                    0x8d59: 0x676d,
                    0x8d5a: 0x6821,
                    0x8d5b: 0x6897,
                    0x8d5c: 0x69cb,
                    0x8d5d: 0x6c5f,
                    0x8d5e: 0x6d2a,
                    0x8d5f: 0x6d69,
                    0x8d60: 0x6e2f,
                    0x8d61: 0x6e9d,
                    0x8d62: 0x7532,
                    0x8d63: 0x7687,
                    0x8d64: 0x786c,
                    0x8d65: 0x7a3f,
                    0x8d66: 0x7ce0,
                    0x8d67: 0x7d05,
                    0x8d68: 0x7d18,
                    0x8d69: 0x7d5e,
                    0x8d6a: 0x7db1,
                    0x8d6b: 0x8015,
                    0x8d6c: 0x8003,
                    0x8d6d: 0x80af,
                    0x8d6e: 0x80b1,
                    0x8d6f: 0x8154,
                    0x8d70: 0x818f,
                    0x8d71: 0x822a,
                    0x8d72: 0x8352,
                    0x8d73: 0x884c,
                    0x8d74: 0x8861,
                    0x8d75: 0x8b1b,
                    0x8d76: 0x8ca2,
                    0x8d77: 0x8cfc,
                    0x8d78: 0x90ca,
                    0x8d79: 0x9175,
                    0x8d7a: 0x9271,
                    0x8d7b: 0x783f,
                    0x8d7c: 0x92fc,
                    0x8d7d: 0x95a4,
                    0x8d7e: 0x964d,
                    0x8d80: 0x9805,
                    0x8d81: 0x9999,
                    0x8d82: 0x9ad8,
                    0x8d83: 0x9d3b,
                    0x8d84: 0x525b,
                    0x8d85: 0x52ab,
                    0x8d86: 0x53f7,
                    0x8d87: 0x5408,
                    0x8d88: 0x58d5,
                    0x8d89: 0x62f7,
                    0x8d8a: 0x6fe0,
                    0x8d8b: 0x8c6a,
                    0x8d8c: 0x8f5f,
                    0x8d8d: 0x9eb9,
                    0x8d8e: 0x514b,
                    0x8d8f: 0x523b,
                    0x8d90: 0x544a,
                    0x8d91: 0x56fd,
                    0x8d92: 0x7a40,
                    0x8d93: 0x9177,
                    0x8d94: 0x9d60,
                    0x8d95: 0x9ed2,
                    0x8d96: 0x7344,
                    0x8d97: 0x6f09,
                    0x8d98: 0x8170,
                    0x8d99: 0x7511,
                    0x8d9a: 0x5ffd,
                    0x8d9b: 0x60da,
                    0x8d9c: 0x9aa8,
                    0x8d9d: 0x72db,
                    0x8d9e: 0x8fbc,
                    0x8d9f: 0x6b64,
                    0x8da0: 0x9803,
                    0x8da1: 0x4eca,
                    0x8da2: 0x56f0,
                    0x8da3: 0x5764,
                    0x8da4: 0x58be,
                    0x8da5: 0x5a5a,
                    0x8da6: 0x6068,
                    0x8da7: 0x61c7,
                    0x8da8: 0x660f,
                    0x8da9: 0x6606,
                    0x8daa: 0x6839,
                    0x8dab: 0x68b1,
                    0x8dac: 0x6df7,
                    0x8dad: 0x75d5,
                    0x8dae: 0x7d3a,
                    0x8daf: 0x826e,
                    0x8db0: 0x9b42,
                    0x8db1: 0x4e9b,
                    0x8db2: 0x4f50,
                    0x8db3: 0x53c9,
                    0x8db4: 0x5506,
                    0x8db5: 0x5d6f,
                    0x8db6: 0x5de6,
                    0x8db7: 0x5dee,
                    0x8db8: 0x67fb,
                    0x8db9: 0x6c99,
                    0x8dba: 0x7473,
                    0x8dbb: 0x7802,
                    0x8dbc: 0x8a50,
                    0x8dbd: 0x9396,
                    0x8dbe: 0x88df,
                    0x8dbf: 0x5750,
                    0x8dc0: 0x5ea7,
                    0x8dc1: 0x632b,
                    0x8dc2: 0x50b5,
                    0x8dc3: 0x50ac,
                    0x8dc4: 0x518d,
                    0x8dc5: 0x6700,
                    0x8dc6: 0x54c9,
                    0x8dc7: 0x585e,
                    0x8dc8: 0x59bb,
                    0x8dc9: 0x5bb0,
                    0x8dca: 0x5f69,
                    0x8dcb: 0x624d,
                    0x8dcc: 0x63a1,
                    0x8dcd: 0x683d,
                    0x8dce: 0x6b73,
                    0x8dcf: 0x6e08,
                    0x8dd0: 0x707d,
                    0x8dd1: 0x91c7,
                    0x8dd2: 0x7280,
                    0x8dd3: 0x7815,
                    0x8dd4: 0x7826,
                    0x8dd5: 0x796d,
                    0x8dd6: 0x658e,
                    0x8dd7: 0x7d30,
                    0x8dd8: 0x83dc,
                    0x8dd9: 0x88c1,
                    0x8dda: 0x8f09,
                    0x8ddb: 0x969b,
                    0x8ddc: 0x5264,
                    0x8ddd: 0x5728,
                    0x8dde: 0x6750,
                    0x8ddf: 0x7f6a,
                    0x8de0: 0x8ca1,
                    0x8de1: 0x51b4,
                    0x8de2: 0x5742,
                    0x8de3: 0x962a,
                    0x8de4: 0x583a,
                    0x8de5: 0x698a,
                    0x8de6: 0x80b4,
                    0x8de7: 0x54b2,
                    0x8de8: 0x5d0e,
                    0x8de9: 0x57fc,
                    0x8dea: 0x7895,
                    0x8deb: 0x9dfa,
                    0x8dec: 0x4f5c,
                    0x8ded: 0x524a,
                    0x8dee: 0x548b,
                    0x8def: 0x643e,
                    0x8df0: 0x6628,
                    0x8df1: 0x6714,
                    0x8df2: 0x67f5,
                    0x8df3: 0x7a84,
                    0x8df4: 0x7b56,
                    0x8df5: 0x7d22,
                    0x8df6: 0x932f,
                    0x8df7: 0x685c,
                    0x8df8: 0x9bad,
                    0x8df9: 0x7b39,
                    0x8dfa: 0x5319,
                    0x8dfb: 0x518a,
                    0x8dfc: 0x5237,
                    0x8e40: 0x5bdf,
                    0x8e41: 0x62f6,
                    0x8e42: 0x64ae,
                    0x8e43: 0x64e6,
                    0x8e44: 0x672d,
                    0x8e45: 0x6bba,
                    0x8e46: 0x85a9,
                    0x8e47: 0x96d1,
                    0x8e48: 0x7690,
                    0x8e49: 0x9bd6,
                    0x8e4a: 0x634c,
                    0x8e4b: 0x9306,
                    0x8e4c: 0x9bab,
                    0x8e4d: 0x76bf,
                    0x8e4e: 0x6652,
                    0x8e4f: 0x4e09,
                    0x8e50: 0x5098,
                    0x8e51: 0x53c2,
                    0x8e52: 0x5c71,
                    0x8e53: 0x60e8,
                    0x8e54: 0x6492,
                    0x8e55: 0x6563,
                    0x8e56: 0x685f,
                    0x8e57: 0x71e6,
                    0x8e58: 0x73ca,
                    0x8e59: 0x7523,
                    0x8e5a: 0x7b97,
                    0x8e5b: 0x7e82,
                    0x8e5c: 0x8695,
                    0x8e5d: 0x8b83,
                    0x8e5e: 0x8cdb,
                    0x8e5f: 0x9178,
                    0x8e60: 0x9910,
                    0x8e61: 0x65ac,
                    0x8e62: 0x66ab,
                    0x8e63: 0x6b8b,
                    0x8e64: 0x4ed5,
                    0x8e65: 0x4ed4,
                    0x8e66: 0x4f3a,
                    0x8e67: 0x4f7f,
                    0x8e68: 0x523a,
                    0x8e69: 0x53f8,
                    0x8e6a: 0x53f2,
                    0x8e6b: 0x55e3,
                    0x8e6c: 0x56db,
                    0x8e6d: 0x58eb,
                    0x8e6e: 0x59cb,
                    0x8e6f: 0x59c9,
                    0x8e70: 0x59ff,
                    0x8e71: 0x5b50,
                    0x8e72: 0x5c4d,
                    0x8e73: 0x5e02,
                    0x8e74: 0x5e2b,
                    0x8e75: 0x5fd7,
                    0x8e76: 0x601d,
                    0x8e77: 0x6307,
                    0x8e78: 0x652f,
                    0x8e79: 0x5b5c,
                    0x8e7a: 0x65af,
                    0x8e7b: 0x65bd,
                    0x8e7c: 0x65e8,
                    0x8e7d: 0x679d,
                    0x8e7e: 0x6b62,
                    0x8e80: 0x6b7b,
                    0x8e81: 0x6c0f,
                    0x8e82: 0x7345,
                    0x8e83: 0x7949,
                    0x8e84: 0x79c1,
                    0x8e85: 0x7cf8,
                    0x8e86: 0x7d19,
                    0x8e87: 0x7d2b,
                    0x8e88: 0x80a2,
                    0x8e89: 0x8102,
                    0x8e8a: 0x81f3,
                    0x8e8b: 0x8996,
                    0x8e8c: 0x8a5e,
                    0x8e8d: 0x8a69,
                    0x8e8e: 0x8a66,
                    0x8e8f: 0x8a8c,
                    0x8e90: 0x8aee,
                    0x8e91: 0x8cc7,
                    0x8e92: 0x8cdc,
                    0x8e93: 0x96cc,
                    0x8e94: 0x98fc,
                    0x8e95: 0x6b6f,
                    0x8e96: 0x4e8b,
                    0x8e97: 0x4f3c,
                    0x8e98: 0x4f8d,
                    0x8e99: 0x5150,
                    0x8e9a: 0x5b57,
                    0x8e9b: 0x5bfa,
                    0x8e9c: 0x6148,
                    0x8e9d: 0x6301,
                    0x8e9e: 0x6642,
                    0x8e9f: 0x6b21,
                    0x8ea0: 0x6ecb,
                    0x8ea1: 0x6cbb,
                    0x8ea2: 0x723e,
                    0x8ea3: 0x74bd,
                    0x8ea4: 0x75d4,
                    0x8ea5: 0x78c1,
                    0x8ea6: 0x793a,
                    0x8ea7: 0x800c,
                    0x8ea8: 0x8033,
                    0x8ea9: 0x81ea,
                    0x8eaa: 0x8494,
                    0x8eab: 0x8f9e,
                    0x8eac: 0x6c50,
                    0x8ead: 0x9e7f,
                    0x8eae: 0x5f0f,
                    0x8eaf: 0x8b58,
                    0x8eb0: 0x9d2b,
                    0x8eb1: 0x7afa,
                    0x8eb2: 0x8ef8,
                    0x8eb3: 0x5b8d,
                    0x8eb4: 0x96eb,
                    0x8eb5: 0x4e03,
                    0x8eb6: 0x53f1,
                    0x8eb7: 0x57f7,
                    0x8eb8: 0x5931,
                    0x8eb9: 0x5ac9,
                    0x8eba: 0x5ba4,
                    0x8ebb: 0x6089,
                    0x8ebc: 0x6e7f,
                    0x8ebd: 0x6f06,
                    0x8ebe: 0x75be,
                    0x8ebf: 0x8cea,
                    0x8ec0: 0x5b9f,
                    0x8ec1: 0x8500,
                    0x8ec2: 0x7be0,
                    0x8ec3: 0x5072,
                    0x8ec4: 0x67f4,
                    0x8ec5: 0x829d,
                    0x8ec6: 0x5c61,
                    0x8ec7: 0x854a,
                    0x8ec8: 0x7e1e,
                    0x8ec9: 0x820e,
                    0x8eca: 0x5199,
                    0x8ecb: 0x5c04,
                    0x8ecc: 0x6368,
                    0x8ecd: 0x8d66,
                    0x8ece: 0x659c,
                    0x8ecf: 0x716e,
                    0x8ed0: 0x793e,
                    0x8ed1: 0x7d17,
                    0x8ed2: 0x8005,
                    0x8ed3: 0x8b1d,
                    0x8ed4: 0x8eca,
                    0x8ed5: 0x906e,
                    0x8ed6: 0x86c7,
                    0x8ed7: 0x90aa,
                    0x8ed8: 0x501f,
                    0x8ed9: 0x52fa,
                    0x8eda: 0x5c3a,
                    0x8edb: 0x6753,
                    0x8edc: 0x707c,
                    0x8edd: 0x7235,
                    0x8ede: 0x914c,
                    0x8edf: 0x91c8,
                    0x8ee0: 0x932b,
                    0x8ee1: 0x82e5,
                    0x8ee2: 0x5bc2,
                    0x8ee3: 0x5f31,
                    0x8ee4: 0x60f9,
                    0x8ee5: 0x4e3b,
                    0x8ee6: 0x53d6,
                    0x8ee7: 0x5b88,
                    0x8ee8: 0x624b,
                    0x8ee9: 0x6731,
                    0x8eea: 0x6b8a,
                    0x8eeb: 0x72e9,
                    0x8eec: 0x73e0,
                    0x8eed: 0x7a2e,
                    0x8eee: 0x816b,
                    0x8eef: 0x8da3,
                    0x8ef0: 0x9152,
                    0x8ef1: 0x9996,
                    0x8ef2: 0x5112,
                    0x8ef3: 0x53d7,
                    0x8ef4: 0x546a,
                    0x8ef5: 0x5bff,
                    0x8ef6: 0x6388,
                    0x8ef7: 0x6a39,
                    0x8ef8: 0x7dac,
                    0x8ef9: 0x9700,
                    0x8efa: 0x56da,
                    0x8efb: 0x53ce,
                    0x8efc: 0x5468,
                    0x8f40: 0x5b97,
                    0x8f41: 0x5c31,
                    0x8f42: 0x5dde,
                    0x8f43: 0x4fee,
                    0x8f44: 0x6101,
                    0x8f45: 0x62fe,
                    0x8f46: 0x6d32,
                    0x8f47: 0x79c0,
                    0x8f48: 0x79cb,
                    0x8f49: 0x7d42,
                    0x8f4a: 0x7e4d,
                    0x8f4b: 0x7fd2,
                    0x8f4c: 0x81ed,
                    0x8f4d: 0x821f,
                    0x8f4e: 0x8490,
                    0x8f4f: 0x8846,
                    0x8f50: 0x8972,
                    0x8f51: 0x8b90,
                    0x8f52: 0x8e74,
                    0x8f53: 0x8f2f,
                    0x8f54: 0x9031,
                    0x8f55: 0x914b,
                    0x8f56: 0x916c,
                    0x8f57: 0x96c6,
                    0x8f58: 0x919c,
                    0x8f59: 0x4ec0,
                    0x8f5a: 0x4f4f,
                    0x8f5b: 0x5145,
                    0x8f5c: 0x5341,
                    0x8f5d: 0x5f93,
                    0x8f5e: 0x620e,
                    0x8f5f: 0x67d4,
                    0x8f60: 0x6c41,
                    0x8f61: 0x6e0b,
                    0x8f62: 0x7363,
                    0x8f63: 0x7e26,
                    0x8f64: 0x91cd,
                    0x8f65: 0x9283,
                    0x8f66: 0x53d4,
                    0x8f67: 0x5919,
                    0x8f68: 0x5bbf,
                    0x8f69: 0x6dd1,
                    0x8f6a: 0x795d,
                    0x8f6b: 0x7e2e,
                    0x8f6c: 0x7c9b,
                    0x8f6d: 0x587e,
                    0x8f6e: 0x719f,
                    0x8f6f: 0x51fa,
                    0x8f70: 0x8853,
                    0x8f71: 0x8ff0,
                    0x8f72: 0x4fca,
                    0x8f73: 0x5cfb,
                    0x8f74: 0x6625,
                    0x8f75: 0x77ac,
                    0x8f76: 0x7ae3,
                    0x8f77: 0x821c,
                    0x8f78: 0x99ff,
                    0x8f79: 0x51c6,
                    0x8f7a: 0x5faa,
                    0x8f7b: 0x65ec,
                    0x8f7c: 0x696f,
                    0x8f7d: 0x6b89,
                    0x8f7e: 0x6df3,
                    0x8f80: 0x6e96,
                    0x8f81: 0x6f64,
                    0x8f82: 0x76fe,
                    0x8f83: 0x7d14,
                    0x8f84: 0x5de1,
                    0x8f85: 0x9075,
                    0x8f86: 0x9187,
                    0x8f87: 0x9806,
                    0x8f88: 0x51e6,
                    0x8f89: 0x521d,
                    0x8f8a: 0x6240,
                    0x8f8b: 0x6691,
                    0x8f8c: 0x66d9,
                    0x8f8d: 0x6e1a,
                    0x8f8e: 0x5eb6,
                    0x8f8f: 0x7dd2,
                    0x8f90: 0x7f72,
                    0x8f91: 0x66f8,
                    0x8f92: 0x85af,
                    0x8f93: 0x85f7,
                    0x8f94: 0x8af8,
                    0x8f95: 0x52a9,
                    0x8f96: 0x53d9,
                    0x8f97: 0x5973,
                    0x8f98: 0x5e8f,
                    0x8f99: 0x5f90,
                    0x8f9a: 0x6055,
                    0x8f9b: 0x92e4,
                    0x8f9c: 0x9664,
                    0x8f9d: 0x50b7,
                    0x8f9e: 0x511f,
                    0x8f9f: 0x52dd,
                    0x8fa0: 0x5320,
                    0x8fa1: 0x5347,
                    0x8fa2: 0x53ec,
                    0x8fa3: 0x54e8,
                    0x8fa4: 0x5546,
                    0x8fa5: 0x5531,
                    0x8fa6: 0x5617,
                    0x8fa7: 0x5968,
                    0x8fa8: 0x59be,
                    0x8fa9: 0x5a3c,
                    0x8faa: 0x5bb5,
                    0x8fab: 0x5c06,
                    0x8fac: 0x5c0f,
                    0x8fad: 0x5c11,
                    0x8fae: 0x5c1a,
                    0x8faf: 0x5e84,
                    0x8fb0: 0x5e8a,
                    0x8fb1: 0x5ee0,
                    0x8fb2: 0x5f70,
                    0x8fb3: 0x627f,
                    0x8fb4: 0x6284,
                    0x8fb5: 0x62db,
                    0x8fb6: 0x638c,
                    0x8fb7: 0x6377,
                    0x8fb8: 0x6607,
                    0x8fb9: 0x660c,
                    0x8fba: 0x662d,
                    0x8fbb: 0x6676,
                    0x8fbc: 0x677e,
                    0x8fbd: 0x68a2,
                    0x8fbe: 0x6a1f,
                    0x8fbf: 0x6a35,
                    0x8fc0: 0x6cbc,
                    0x8fc1: 0x6d88,
                    0x8fc2: 0x6e09,
                    0x8fc3: 0x6e58,
                    0x8fc4: 0x713c,
                    0x8fc5: 0x7126,
                    0x8fc6: 0x7167,
                    0x8fc7: 0x75c7,
                    0x8fc8: 0x7701,
                    0x8fc9: 0x785d,
                    0x8fca: 0x7901,
                    0x8fcb: 0x7965,
                    0x8fcc: 0x79f0,
                    0x8fcd: 0x7ae0,
                    0x8fce: 0x7b11,
                    0x8fcf: 0x7ca7,
                    0x8fd0: 0x7d39,
                    0x8fd1: 0x8096,
                    0x8fd2: 0x83d6,
                    0x8fd3: 0x848b,
                    0x8fd4: 0x8549,
                    0x8fd5: 0x885d,
                    0x8fd6: 0x88f3,
                    0x8fd7: 0x8a1f,
                    0x8fd8: 0x8a3c,
                    0x8fd9: 0x8a54,
                    0x8fda: 0x8a73,
                    0x8fdb: 0x8c61,
                    0x8fdc: 0x8cde,
                    0x8fdd: 0x91a4,
                    0x8fde: 0x9266,
                    0x8fdf: 0x937e,
                    0x8fe0: 0x9418,
                    0x8fe1: 0x969c,
                    0x8fe2: 0x9798,
                    0x8fe3: 0x4e0a,
                    0x8fe4: 0x4e08,
                    0x8fe5: 0x4e1e,
                    0x8fe6: 0x4e57,
                    0x8fe7: 0x5197,
                    0x8fe8: 0x5270,
                    0x8fe9: 0x57ce,
                    0x8fea: 0x5834,
                    0x8feb: 0x58cc,
                    0x8fec: 0x5b22,
                    0x8fed: 0x5e38,
                    0x8fee: 0x60c5,
                    0x8fef: 0x64fe,
                    0x8ff0: 0x6761,
                    0x8ff1: 0x6756,
                    0x8ff2: 0x6d44,
                    0x8ff3: 0x72b6,
                    0x8ff4: 0x7573,
                    0x8ff5: 0x7a63,
                    0x8ff6: 0x84b8,
                    0x8ff7: 0x8b72,
                    0x8ff8: 0x91b8,
                    0x8ff9: 0x9320,
                    0x8ffa: 0x5631,
                    0x8ffb: 0x57f4,
                    0x8ffc: 0x98fe,
                    0x9040: 0x62ed,
                    0x9041: 0x690d,
                    0x9042: 0x6b96,
                    0x9043: 0x71ed,
                    0x9044: 0x7e54,
                    0x9045: 0x8077,
                    0x9046: 0x8272,
                    0x9047: 0x89e6,
                    0x9048: 0x98df,
                    0x9049: 0x8755,
                    0x904a: 0x8fb1,
                    0x904b: 0x5c3b,
                    0x904c: 0x4f38,
                    0x904d: 0x4fe1,
                    0x904e: 0x4fb5,
                    0x904f: 0x5507,
                    0x9050: 0x5a20,
                    0x9051: 0x5bdd,
                    0x9052: 0x5be9,
                    0x9053: 0x5fc3,
                    0x9054: 0x614e,
                    0x9055: 0x632f,
                    0x9056: 0x65b0,
                    0x9057: 0x664b,
                    0x9058: 0x68ee,
                    0x9059: 0x699b,
                    0x905a: 0x6d78,
                    0x905b: 0x6df1,
                    0x905c: 0x7533,
                    0x905d: 0x75b9,
                    0x905e: 0x771f,
                    0x905f: 0x795e,
                    0x9060: 0x79e6,
                    0x9061: 0x7d33,
                    0x9062: 0x81e3,
                    0x9063: 0x82af,
                    0x9064: 0x85aa,
                    0x9065: 0x89aa,
                    0x9066: 0x8a3a,
                    0x9067: 0x8eab,
                    0x9068: 0x8f9b,
                    0x9069: 0x9032,
                    0x906a: 0x91dd,
                    0x906b: 0x9707,
                    0x906c: 0x4eba,
                    0x906d: 0x4ec1,
                    0x906e: 0x5203,
                    0x906f: 0x5875,
                    0x9070: 0x58ec,
                    0x9071: 0x5c0b,
                    0x9072: 0x751a,
                    0x9073: 0x5c3d,
                    0x9074: 0x814e,
                    0x9075: 0x8a0a,
                    0x9076: 0x8fc5,
                    0x9077: 0x9663,
                    0x9078: 0x976d,
                    0x9079: 0x7b25,
                    0x907a: 0x8acf,
                    0x907b: 0x9808,
                    0x907c: 0x9162,
                    0x907d: 0x56f3,
                    0x907e: 0x53a8,
                    0x9080: 0x9017,
                    0x9081: 0x5439,
                    0x9082: 0x5782,
                    0x9083: 0x5e25,
                    0x9084: 0x63a8,
                    0x9085: 0x6c34,
                    0x9086: 0x708a,
                    0x9087: 0x7761,
                    0x9088: 0x7c8b,
                    0x9089: 0x7fe0,
                    0x908a: 0x8870,
                    0x908b: 0x9042,
                    0x908c: 0x9154,
                    0x908d: 0x9310,
                    0x908e: 0x9318,
                    0x908f: 0x968f,
                    0x9090: 0x745e,
                    0x9091: 0x9ac4,
                    0x9092: 0x5d07,
                    0x9093: 0x5d69,
                    0x9094: 0x6570,
                    0x9095: 0x67a2,
                    0x9096: 0x8da8,
                    0x9097: 0x96db,
                    0x9098: 0x636e,
                    0x9099: 0x6749,
                    0x909a: 0x6919,
                    0x909b: 0x83c5,
                    0x909c: 0x9817,
                    0x909d: 0x96c0,
                    0x909e: 0x88fe,
                    0x909f: 0x6f84,
                    0x90a0: 0x647a,
                    0x90a1: 0x5bf8,
                    0x90a2: 0x4e16,
                    0x90a3: 0x702c,
                    0x90a4: 0x755d,
                    0x90a5: 0x662f,
                    0x90a6: 0x51c4,
                    0x90a7: 0x5236,
                    0x90a8: 0x52e2,
                    0x90a9: 0x59d3,
                    0x90aa: 0x5f81,
                    0x90ab: 0x6027,
                    0x90ac: 0x6210,
                    0x90ad: 0x653f,
                    0x90ae: 0x6574,
                    0x90af: 0x661f,
                    0x90b0: 0x6674,
                    0x90b1: 0x68f2,
                    0x90b2: 0x6816,
                    0x90b3: 0x6b63,
                    0x90b4: 0x6e05,
                    0x90b5: 0x7272,
                    0x90b6: 0x751f,
                    0x90b7: 0x76db,
                    0x90b8: 0x7cbe,
                    0x90b9: 0x8056,
                    0x90ba: 0x58f0,
                    0x90bb: 0x88fd,
                    0x90bc: 0x897f,
                    0x90bd: 0x8aa0,
                    0x90be: 0x8a93,
                    0x90bf: 0x8acb,
                    0x90c0: 0x901d,
                    0x90c1: 0x9192,
                    0x90c2: 0x9752,
                    0x90c3: 0x9759,
                    0x90c4: 0x6589,
                    0x90c5: 0x7a0e,
                    0x90c6: 0x8106,
                    0x90c7: 0x96bb,
                    0x90c8: 0x5e2d,
                    0x90c9: 0x60dc,
                    0x90ca: 0x621a,
                    0x90cb: 0x65a5,
                    0x90cc: 0x6614,
                    0x90cd: 0x6790,
                    0x90ce: 0x77f3,
                    0x90cf: 0x7a4d,
                    0x90d0: 0x7c4d,
                    0x90d1: 0x7e3e,
                    0x90d2: 0x810a,
                    0x90d3: 0x8cac,
                    0x90d4: 0x8d64,
                    0x90d5: 0x8de1,
                    0x90d6: 0x8e5f,
                    0x90d7: 0x78a9,
                    0x90d8: 0x5207,
                    0x90d9: 0x62d9,
                    0x90da: 0x63a5,
                    0x90db: 0x6442,
                    0x90dc: 0x6298,
                    0x90dd: 0x8a2d,
                    0x90de: 0x7a83,
                    0x90df: 0x7bc0,
                    0x90e0: 0x8aac,
                    0x90e1: 0x96ea,
                    0x90e2: 0x7d76,
                    0x90e3: 0x820c,
                    0x90e4: 0x8749,
                    0x90e5: 0x4ed9,
                    0x90e6: 0x5148,
                    0x90e7: 0x5343,
                    0x90e8: 0x5360,
                    0x90e9: 0x5ba3,
                    0x90ea: 0x5c02,
                    0x90eb: 0x5c16,
                    0x90ec: 0x5ddd,
                    0x90ed: 0x6226,
                    0x90ee: 0x6247,
                    0x90ef: 0x64b0,
                    0x90f0: 0x6813,
                    0x90f1: 0x6834,
                    0x90f2: 0x6cc9,
                    0x90f3: 0x6d45,
                    0x90f4: 0x6d17,
                    0x90f5: 0x67d3,
                    0x90f6: 0x6f5c,
                    0x90f7: 0x714e,
                    0x90f8: 0x717d,
                    0x90f9: 0x65cb,
                    0x90fa: 0x7a7f,
                    0x90fb: 0x7bad,
                    0x90fc: 0x7dda,
                    0x9140: 0x7e4a,
                    0x9141: 0x7fa8,
                    0x9142: 0x817a,
                    0x9143: 0x821b,
                    0x9144: 0x8239,
                    0x9145: 0x85a6,
                    0x9146: 0x8a6e,
                    0x9147: 0x8cce,
                    0x9148: 0x8df5,
                    0x9149: 0x9078,
                    0x914a: 0x9077,
                    0x914b: 0x92ad,
                    0x914c: 0x9291,
                    0x914d: 0x9583,
                    0x914e: 0x9bae,
                    0x914f: 0x524d,
                    0x9150: 0x5584,
                    0x9151: 0x6f38,
                    0x9152: 0x7136,
                    0x9153: 0x5168,
                    0x9154: 0x7985,
                    0x9155: 0x7e55,
                    0x9156: 0x81b3,
                    0x9157: 0x7cce,
                    0x9158: 0x564c,
                    0x9159: 0x5851,
                    0x915a: 0x5ca8,
                    0x915b: 0x63aa,
                    0x915c: 0x66fe,
                    0x915d: 0x66fd,
                    0x915e: 0x695a,
                    0x915f: 0x72d9,
                    0x9160: 0x758f,
                    0x9161: 0x758e,
                    0x9162: 0x790e,
                    0x9163: 0x7956,
                    0x9164: 0x79df,
                    0x9165: 0x7c97,
                    0x9166: 0x7d20,
                    0x9167: 0x7d44,
                    0x9168: 0x8607,
                    0x9169: 0x8a34,
                    0x916a: 0x963b,
                    0x916b: 0x9061,
                    0x916c: 0x9f20,
                    0x916d: 0x50e7,
                    0x916e: 0x5275,
                    0x916f: 0x53cc,
                    0x9170: 0x53e2,
                    0x9171: 0x5009,
                    0x9172: 0x55aa,
                    0x9173: 0x58ee,
                    0x9174: 0x594f,
                    0x9175: 0x723d,
                    0x9176: 0x5b8b,
                    0x9177: 0x5c64,
                    0x9178: 0x531d,
                    0x9179: 0x60e3,
                    0x917a: 0x60f3,
                    0x917b: 0x635c,
                    0x917c: 0x6383,
                    0x917d: 0x633f,
                    0x917e: 0x63bb,
                    0x9180: 0x64cd,
                    0x9181: 0x65e9,
                    0x9182: 0x66f9,
                    0x9183: 0x5de3,
                    0x9184: 0x69cd,
                    0x9185: 0x69fd,
                    0x9186: 0x6f15,
                    0x9187: 0x71e5,
                    0x9188: 0x4e89,
                    0x9189: 0x75e9,
                    0x918a: 0x76f8,
                    0x918b: 0x7a93,
                    0x918c: 0x7cdf,
                    0x918d: 0x7dcf,
                    0x918e: 0x7d9c,
                    0x918f: 0x8061,
                    0x9190: 0x8349,
                    0x9191: 0x8358,
                    0x9192: 0x846c,
                    0x9193: 0x84bc,
                    0x9194: 0x85fb,
                    0x9195: 0x88c5,
                    0x9196: 0x8d70,
                    0x9197: 0x9001,
                    0x9198: 0x906d,
                    0x9199: 0x9397,
                    0x919a: 0x971c,
                    0x919b: 0x9a12,
                    0x919c: 0x50cf,
                    0x919d: 0x5897,
                    0x919e: 0x618e,
                    0x919f: 0x81d3,
                    0x91a0: 0x8535,
                    0x91a1: 0x8d08,
                    0x91a2: 0x9020,
                    0x91a3: 0x4fc3,
                    0x91a4: 0x5074,
                    0x91a5: 0x5247,
                    0x91a6: 0x5373,
                    0x91a7: 0x606f,
                    0x91a8: 0x6349,
                    0x91a9: 0x675f,
                    0x91aa: 0x6e2c,
                    0x91ab: 0x8db3,
                    0x91ac: 0x901f,
                    0x91ad: 0x4fd7,
                    0x91ae: 0x5c5e,
                    0x91af: 0x8cca,
                    0x91b0: 0x65cf,
                    0x91b1: 0x7d9a,
                    0x91b2: 0x5352,
                    0x91b3: 0x8896,
                    0x91b4: 0x5176,
                    0x91b5: 0x63c3,
                    0x91b6: 0x5b58,
                    0x91b7: 0x5b6b,
                    0x91b8: 0x5c0a,
                    0x91b9: 0x640d,
                    0x91ba: 0x6751,
                    0x91bb: 0x905c,
                    0x91bc: 0x4ed6,
                    0x91bd: 0x591a,
                    0x91be: 0x592a,
                    0x91bf: 0x6c70,
                    0x91c0: 0x8a51,
                    0x91c1: 0x553e,
                    0x91c2: 0x5815,
                    0x91c3: 0x59a5,
                    0x91c4: 0x60f0,
                    0x91c5: 0x6253,
                    0x91c6: 0x67c1,
                    0x91c7: 0x8235,
                    0x91c8: 0x6955,
                    0x91c9: 0x9640,
                    0x91ca: 0x99c4,
                    0x91cb: 0x9a28,
                    0x91cc: 0x4f53,
                    0x91cd: 0x5806,
                    0x91ce: 0x5bfe,
                    0x91cf: 0x8010,
                    0x91d0: 0x5cb1,
                    0x91d1: 0x5e2f,
                    0x91d2: 0x5f85,
                    0x91d3: 0x6020,
                    0x91d4: 0x614b,
                    0x91d5: 0x6234,
                    0x91d6: 0x66ff,
                    0x91d7: 0x6cf0,
                    0x91d8: 0x6ede,
                    0x91d9: 0x80ce,
                    0x91da: 0x817f,
                    0x91db: 0x82d4,
                    0x91dc: 0x888b,
                    0x91dd: 0x8cb8,
                    0x91de: 0x9000,
                    0x91df: 0x902e,
                    0x91e0: 0x968a,
                    0x91e1: 0x9edb,
                    0x91e2: 0x9bdb,
                    0x91e3: 0x4ee3,
                    0x91e4: 0x53f0,
                    0x91e5: 0x5927,
                    0x91e6: 0x7b2c,
                    0x91e7: 0x918d,
                    0x91e8: 0x984c,
                    0x91e9: 0x9df9,
                    0x91ea: 0x6edd,
                    0x91eb: 0x7027,
                    0x91ec: 0x5353,
                    0x91ed: 0x5544,
                    0x91ee: 0x5b85,
                    0x91ef: 0x6258,
                    0x91f0: 0x629e,
                    0x91f1: 0x62d3,
                    0x91f2: 0x6ca2,
                    0x91f3: 0x6fef,
                    0x91f4: 0x7422,
                    0x91f5: 0x8a17,
                    0x91f6: 0x9438,
                    0x91f7: 0x6fc1,
                    0x91f8: 0x8afe,
                    0x91f9: 0x8338,
                    0x91fa: 0x51e7,
                    0x91fb: 0x86f8,
                    0x91fc: 0x53ea,
                    0x9240: 0x53e9,
                    0x9241: 0x4f46,
                    0x9242: 0x9054,
                    0x9243: 0x8fb0,
                    0x9244: 0x596a,
                    0x9245: 0x8131,
                    0x9246: 0x5dfd,
                    0x9247: 0x7aea,
                    0x9248: 0x8fbf,
                    0x9249: 0x68da,
                    0x924a: 0x8c37,
                    0x924b: 0x72f8,
                    0x924c: 0x9c48,
                    0x924d: 0x6a3d,
                    0x924e: 0x8ab0,
                    0x924f: 0x4e39,
                    0x9250: 0x5358,
                    0x9251: 0x5606,
                    0x9252: 0x5766,
                    0x9253: 0x62c5,
                    0x9254: 0x63a2,
                    0x9255: 0x65e6,
                    0x9256: 0x6b4e,
                    0x9257: 0x6de1,
                    0x9258: 0x6e5b,
                    0x9259: 0x70ad,
                    0x925a: 0x77ed,
                    0x925b: 0x7aef,
                    0x925c: 0x7baa,
                    0x925d: 0x7dbb,
                    0x925e: 0x803d,
                    0x925f: 0x80c6,
                    0x9260: 0x86cb,
                    0x9261: 0x8a95,
                    0x9262: 0x935b,
                    0x9263: 0x56e3,
                    0x9264: 0x58c7,
                    0x9265: 0x5f3e,
                    0x9266: 0x65ad,
                    0x9267: 0x6696,
                    0x9268: 0x6a80,
                    0x9269: 0x6bb5,
                    0x926a: 0x7537,
                    0x926b: 0x8ac7,
                    0x926c: 0x5024,
                    0x926d: 0x77e5,
                    0x926e: 0x5730,
                    0x926f: 0x5f1b,
                    0x9270: 0x6065,
                    0x9271: 0x667a,
                    0x9272: 0x6c60,
                    0x9273: 0x75f4,
                    0x9274: 0x7a1a,
                    0x9275: 0x7f6e,
                    0x9276: 0x81f4,
                    0x9277: 0x8718,
                    0x9278: 0x9045,
                    0x9279: 0x99b3,
                    0x927a: 0x7bc9,
                    0x927b: 0x755c,
                    0x927c: 0x7af9,
                    0x927d: 0x7b51,
                    0x927e: 0x84c4,
                    0x9280: 0x9010,
                    0x9281: 0x79e9,
                    0x9282: 0x7a92,
                    0x9283: 0x8336,
                    0x9284: 0x5ae1,
                    0x9285: 0x7740,
                    0x9286: 0x4e2d,
                    0x9287: 0x4ef2,
                    0x9288: 0x5b99,
                    0x9289: 0x5fe0,
                    0x928a: 0x62bd,
                    0x928b: 0x663c,
                    0x928c: 0x67f1,
                    0x928d: 0x6ce8,
                    0x928e: 0x866b,
                    0x928f: 0x8877,
                    0x9290: 0x8a3b,
                    0x9291: 0x914e,
                    0x9292: 0x92f3,
                    0x9293: 0x99d0,
                    0x9294: 0x6a17,
                    0x9295: 0x7026,
                    0x9296: 0x732a,
                    0x9297: 0x82e7,
                    0x9298: 0x8457,
                    0x9299: 0x8caf,
                    0x929a: 0x4e01,
                    0x929b: 0x5146,
                    0x929c: 0x51cb,
                    0x929d: 0x558b,
                    0x929e: 0x5bf5,
                    0x929f: 0x5e16,
                    0x92a0: 0x5e33,
                    0x92a1: 0x5e81,
                    0x92a2: 0x5f14,
                    0x92a3: 0x5f35,
                    0x92a4: 0x5f6b,
                    0x92a5: 0x5fb4,
                    0x92a6: 0x61f2,
                    0x92a7: 0x6311,
                    0x92a8: 0x66a2,
                    0x92a9: 0x671d,
                    0x92aa: 0x6f6e,
                    0x92ab: 0x7252,
                    0x92ac: 0x753a,
                    0x92ad: 0x773a,
                    0x92ae: 0x8074,
                    0x92af: 0x8139,
                    0x92b0: 0x8178,
                    0x92b1: 0x8776,
                    0x92b2: 0x8abf,
                    0x92b3: 0x8adc,
                    0x92b4: 0x8d85,
                    0x92b5: 0x8df3,
                    0x92b6: 0x929a,
                    0x92b7: 0x9577,
                    0x92b8: 0x9802,
                    0x92b9: 0x9ce5,
                    0x92ba: 0x52c5,
                    0x92bb: 0x6357,
                    0x92bc: 0x76f4,
                    0x92bd: 0x6715,
                    0x92be: 0x6c88,
                    0x92bf: 0x73cd,
                    0x92c0: 0x8cc3,
                    0x92c1: 0x93ae,
                    0x92c2: 0x9673,
                    0x92c3: 0x6d25,
                    0x92c4: 0x589c,
                    0x92c5: 0x690e,
                    0x92c6: 0x69cc,
                    0x92c7: 0x8ffd,
                    0x92c8: 0x939a,
                    0x92c9: 0x75db,
                    0x92ca: 0x901a,
                    0x92cb: 0x585a,
                    0x92cc: 0x6802,
                    0x92cd: 0x63b4,
                    0x92ce: 0x69fb,
                    0x92cf: 0x4f43,
                    0x92d0: 0x6f2c,
                    0x92d1: 0x67d8,
                    0x92d2: 0x8fbb,
                    0x92d3: 0x8526,
                    0x92d4: 0x7db4,
                    0x92d5: 0x9354,
                    0x92d6: 0x693f,
                    0x92d7: 0x6f70,
                    0x92d8: 0x576a,
                    0x92d9: 0x58f7,
                    0x92da: 0x5b2c,
                    0x92db: 0x7d2c,
                    0x92dc: 0x722a,
                    0x92dd: 0x540a,
                    0x92de: 0x91e3,
                    0x92df: 0x9db4,
                    0x92e0: 0x4ead,
                    0x92e1: 0x4f4e,
                    0x92e2: 0x505c,
                    0x92e3: 0x5075,
                    0x92e4: 0x5243,
                    0x92e5: 0x8c9e,
                    0x92e6: 0x5448,
                    0x92e7: 0x5824,
                    0x92e8: 0x5b9a,
                    0x92e9: 0x5e1d,
                    0x92ea: 0x5e95,
                    0x92eb: 0x5ead,
                    0x92ec: 0x5ef7,
                    0x92ed: 0x5f1f,
                    0x92ee: 0x608c,
                    0x92ef: 0x62b5,
                    0x92f0: 0x633a,
                    0x92f1: 0x63d0,
                    0x92f2: 0x68af,
                    0x92f3: 0x6c40,
                    0x92f4: 0x7887,
                    0x92f5: 0x798e,
                    0x92f6: 0x7a0b,
                    0x92f7: 0x7de0,
                    0x92f8: 0x8247,
                    0x92f9: 0x8a02,
                    0x92fa: 0x8ae6,
                    0x92fb: 0x8e44,
                    0x92fc: 0x9013,
                    0x9340: 0x90b8,
                    0x9341: 0x912d,
                    0x9342: 0x91d8,
                    0x9343: 0x9f0e,
                    0x9344: 0x6ce5,
                    0x9345: 0x6458,
                    0x9346: 0x64e2,
                    0x9347: 0x6575,
                    0x9348: 0x6ef4,
                    0x9349: 0x7684,
                    0x934a: 0x7b1b,
                    0x934b: 0x9069,
                    0x934c: 0x93d1,
                    0x934d: 0x6eba,
                    0x934e: 0x54f2,
                    0x934f: 0x5fb9,
                    0x9350: 0x64a4,
                    0x9351: 0x8f4d,
                    0x9352: 0x8fed,
                    0x9353: 0x9244,
                    0x9354: 0x5178,
                    0x9355: 0x586b,
                    0x9356: 0x5929,
                    0x9357: 0x5c55,
                    0x9358: 0x5e97,
                    0x9359: 0x6dfb,
                    0x935a: 0x7e8f,
                    0x935b: 0x751c,
                    0x935c: 0x8cbc,
                    0x935d: 0x8ee2,
                    0x935e: 0x985b,
                    0x935f: 0x70b9,
                    0x9360: 0x4f1d,
                    0x9361: 0x6bbf,
                    0x9362: 0x6fb1,
                    0x9363: 0x7530,
                    0x9364: 0x96fb,
                    0x9365: 0x514e,
                    0x9366: 0x5410,
                    0x9367: 0x5835,
                    0x9368: 0x5857,
                    0x9369: 0x59ac,
                    0x936a: 0x5c60,
                    0x936b: 0x5f92,
                    0x936c: 0x6597,
                    0x936d: 0x675c,
                    0x936e: 0x6e21,
                    0x936f: 0x767b,
                    0x9370: 0x83df,
                    0x9371: 0x8ced,
                    0x9372: 0x9014,
                    0x9373: 0x90fd,
                    0x9374: 0x934d,
                    0x9375: 0x7825,
                    0x9376: 0x783a,
                    0x9377: 0x52aa,
                    0x9378: 0x5ea6,
                    0x9379: 0x571f,
                    0x937a: 0x5974,
                    0x937b: 0x6012,
                    0x937c: 0x5012,
                    0x937d: 0x515a,
                    0x937e: 0x51ac,
                    0x9380: 0x51cd,
                    0x9381: 0x5200,
                    0x9382: 0x5510,
                    0x9383: 0x5854,
                    0x9384: 0x5858,
                    0x9385: 0x5957,
                    0x9386: 0x5b95,
                    0x9387: 0x5cf6,
                    0x9388: 0x5d8b,
                    0x9389: 0x60bc,
                    0x938a: 0x6295,
                    0x938b: 0x642d,
                    0x938c: 0x6771,
                    0x938d: 0x6843,
                    0x938e: 0x68bc,
                    0x938f: 0x68df,
                    0x9390: 0x76d7,
                    0x9391: 0x6dd8,
                    0x9392: 0x6e6f,
                    0x9393: 0x6d9b,
                    0x9394: 0x706f,
                    0x9395: 0x71c8,
                    0x9396: 0x5f53,
                    0x9397: 0x75d8,
                    0x9398: 0x7977,
                    0x9399: 0x7b49,
                    0x939a: 0x7b54,
                    0x939b: 0x7b52,
                    0x939c: 0x7cd6,
                    0x939d: 0x7d71,
                    0x939e: 0x5230,
                    0x939f: 0x8463,
                    0x93a0: 0x8569,
                    0x93a1: 0x85e4,
                    0x93a2: 0x8a0e,
                    0x93a3: 0x8b04,
                    0x93a4: 0x8c46,
                    0x93a5: 0x8e0f,
                    0x93a6: 0x9003,
                    0x93a7: 0x900f,
                    0x93a8: 0x9419,
                    0x93a9: 0x9676,
                    0x93aa: 0x982d,
                    0x93ab: 0x9a30,
                    0x93ac: 0x95d8,
                    0x93ad: 0x50cd,
                    0x93ae: 0x52d5,
                    0x93af: 0x540c,
                    0x93b0: 0x5802,
                    0x93b1: 0x5c0e,
                    0x93b2: 0x61a7,
                    0x93b3: 0x649e,
                    0x93b4: 0x6d1e,
                    0x93b5: 0x77b3,
                    0x93b6: 0x7ae5,
                    0x93b7: 0x80f4,
                    0x93b8: 0x8404,
                    0x93b9: 0x9053,
                    0x93ba: 0x9285,
                    0x93bb: 0x5ce0,
                    0x93bc: 0x9d07,
                    0x93bd: 0x533f,
                    0x93be: 0x5f97,
                    0x93bf: 0x5fb3,
                    0x93c0: 0x6d9c,
                    0x93c1: 0x7279,
                    0x93c2: 0x7763,
                    0x93c3: 0x79bf,
                    0x93c4: 0x7be4,
                    0x93c5: 0x6bd2,
                    0x93c6: 0x72ec,
                    0x93c7: 0x8aad,
                    0x93c8: 0x6803,
                    0x93c9: 0x6a61,
                    0x93ca: 0x51f8,
                    0x93cb: 0x7a81,
                    0x93cc: 0x6934,
                    0x93cd: 0x5c4a,
                    0x93ce: 0x9cf6,
                    0x93cf: 0x82eb,
                    0x93d0: 0x5bc5,
                    0x93d1: 0x9149,
                    0x93d2: 0x701e,
                    0x93d3: 0x5678,
                    0x93d4: 0x5c6f,
                    0x93d5: 0x60c7,
                    0x93d6: 0x6566,
                    0x93d7: 0x6c8c,
                    0x93d8: 0x8c5a,
                    0x93d9: 0x9041,
                    0x93da: 0x9813,
                    0x93db: 0x5451,
                    0x93dc: 0x66c7,
                    0x93dd: 0x920d,
                    0x93de: 0x5948,
                    0x93df: 0x90a3,
                    0x93e0: 0x5185,
                    0x93e1: 0x4e4d,
                    0x93e2: 0x51ea,
                    0x93e3: 0x8599,
                    0x93e4: 0x8b0e,
                    0x93e5: 0x7058,
                    0x93e6: 0x637a,
                    0x93e7: 0x934b,
                    0x93e8: 0x6962,
                    0x93e9: 0x99b4,
                    0x93ea: 0x7e04,
                    0x93eb: 0x7577,
                    0x93ec: 0x5357,
                    0x93ed: 0x6960,
                    0x93ee: 0x8edf,
                    0x93ef: 0x96e3,
                    0x93f0: 0x6c5d,
                    0x93f1: 0x4e8c,
                    0x93f2: 0x5c3c,
                    0x93f3: 0x5f10,
                    0x93f4: 0x8fe9,
                    0x93f5: 0x5302,
                    0x93f6: 0x8cd1,
                    0x93f7: 0x8089,
                    0x93f8: 0x8679,
                    0x93f9: 0x5eff,
                    0x93fa: 0x65e5,
                    0x93fb: 0x4e73,
                    0x93fc: 0x5165,
                    0x9440: 0x5982,
                    0x9441: 0x5c3f,
                    0x9442: 0x97ee,
                    0x9443: 0x4efb,
                    0x9444: 0x598a,
                    0x9445: 0x5fcd,
                    0x9446: 0x8a8d,
                    0x9447: 0x6fe1,
                    0x9448: 0x79b0,
                    0x9449: 0x7962,
                    0x944a: 0x5be7,
                    0x944b: 0x8471,
                    0x944c: 0x732b,
                    0x944d: 0x71b1,
                    0x944e: 0x5e74,
                    0x944f: 0x5ff5,
                    0x9450: 0x637b,
                    0x9451: 0x649a,
                    0x9452: 0x71c3,
                    0x9453: 0x7c98,
                    0x9454: 0x4e43,
                    0x9455: 0x5efc,
                    0x9456: 0x4e4b,
                    0x9457: 0x57dc,
                    0x9458: 0x56a2,
                    0x9459: 0x60a9,
                    0x945a: 0x6fc3,
                    0x945b: 0x7d0d,
                    0x945c: 0x80fd,
                    0x945d: 0x8133,
                    0x945e: 0x81bf,
                    0x945f: 0x8fb2,
                    0x9460: 0x8997,
                    0x9461: 0x86a4,
                    0x9462: 0x5df4,
                    0x9463: 0x628a,
                    0x9464: 0x64ad,
                    0x9465: 0x8987,
                    0x9466: 0x6777,
                    0x9467: 0x6ce2,
                    0x9468: 0x6d3e,
                    0x9469: 0x7436,
                    0x946a: 0x7834,
                    0x946b: 0x5a46,
                    0x946c: 0x7f75,
                    0x946d: 0x82ad,
                    0x946e: 0x99ac,
                    0x946f: 0x4ff3,
                    0x9470: 0x5ec3,
                    0x9471: 0x62dd,
                    0x9472: 0x6392,
                    0x9473: 0x6557,
                    0x9474: 0x676f,
                    0x9475: 0x76c3,
                    0x9476: 0x724c,
                    0x9477: 0x80cc,
                    0x9478: 0x80ba,
                    0x9479: 0x8f29,
                    0x947a: 0x914d,
                    0x947b: 0x500d,
                    0x947c: 0x57f9,
                    0x947d: 0x5a92,
                    0x947e: 0x6885,
                    0x9480: 0x6973,
                    0x9481: 0x7164,
                    0x9482: 0x72fd,
                    0x9483: 0x8cb7,
                    0x9484: 0x58f2,
                    0x9485: 0x8ce0,
                    0x9486: 0x966a,
                    0x9487: 0x9019,
                    0x9488: 0x877f,
                    0x9489: 0x79e4,
                    0x948a: 0x77e7,
                    0x948b: 0x8429,
                    0x948c: 0x4f2f,
                    0x948d: 0x5265,
                    0x948e: 0x535a,
                    0x948f: 0x62cd,
                    0x9490: 0x67cf,
                    0x9491: 0x6cca,
                    0x9492: 0x767d,
                    0x9493: 0x7b94,
                    0x9494: 0x7c95,
                    0x9495: 0x8236,
                    0x9496: 0x8584,
                    0x9497: 0x8feb,
                    0x9498: 0x66dd,
                    0x9499: 0x6f20,
                    0x949a: 0x7206,
                    0x949b: 0x7e1b,
                    0x949c: 0x83ab,
                    0x949d: 0x99c1,
                    0x949e: 0x9ea6,
                    0x949f: 0x51fd,
                    0x94a0: 0x7bb1,
                    0x94a1: 0x7872,
                    0x94a2: 0x7bb8,
                    0x94a3: 0x8087,
                    0x94a4: 0x7b48,
                    0x94a5: 0x6ae8,
                    0x94a6: 0x5e61,
                    0x94a7: 0x808c,
                    0x94a8: 0x7551,
                    0x94a9: 0x7560,
                    0x94aa: 0x516b,
                    0x94ab: 0x9262,
                    0x94ac: 0x6e8c,
                    0x94ad: 0x767a,
                    0x94ae: 0x9197,
                    0x94af: 0x9aea,
                    0x94b0: 0x4f10,
                    0x94b1: 0x7f70,
                    0x94b2: 0x629c,
                    0x94b3: 0x7b4f,
                    0x94b4: 0x95a5,
                    0x94b5: 0x9ce9,
                    0x94b6: 0x567a,
                    0x94b7: 0x5859,
                    0x94b8: 0x86e4,
                    0x94b9: 0x96bc,
                    0x94ba: 0x4f34,
                    0x94bb: 0x5224,
                    0x94bc: 0x534a,
                    0x94bd: 0x53cd,
                    0x94be: 0x53db,
                    0x94bf: 0x5e06,
                    0x94c0: 0x642c,
                    0x94c1: 0x6591,
                    0x94c2: 0x677f,
                    0x94c3: 0x6c3e,
                    0x94c4: 0x6c4e,
                    0x94c5: 0x7248,
                    0x94c6: 0x72af,
                    0x94c7: 0x73ed,
                    0x94c8: 0x7554,
                    0x94c9: 0x7e41,
                    0x94ca: 0x822c,
                    0x94cb: 0x85e9,
                    0x94cc: 0x8ca9,
                    0x94cd: 0x7bc4,
                    0x94ce: 0x91c6,
                    0x94cf: 0x7169,
                    0x94d0: 0x9812,
                    0x94d1: 0x98ef,
                    0x94d2: 0x633d,
                    0x94d3: 0x6669,
                    0x94d4: 0x756a,
                    0x94d5: 0x76e4,
                    0x94d6: 0x78d0,
                    0x94d7: 0x8543,
                    0x94d8: 0x86ee,
                    0x94d9: 0x532a,
                    0x94da: 0x5351,
                    0x94db: 0x5426,
                    0x94dc: 0x5983,
                    0x94dd: 0x5e87,
                    0x94de: 0x5f7c,
                    0x94df: 0x60b2,
                    0x94e0: 0x6249,
                    0x94e1: 0x6279,
                    0x94e2: 0x62ab,
                    0x94e3: 0x6590,
                    0x94e4: 0x6bd4,
                    0x94e5: 0x6ccc,
                    0x94e6: 0x75b2,
                    0x94e7: 0x76ae,
                    0x94e8: 0x7891,
                    0x94e9: 0x79d8,
                    0x94ea: 0x7dcb,
                    0x94eb: 0x7f77,
                    0x94ec: 0x80a5,
                    0x94ed: 0x88ab,
                    0x94ee: 0x8ab9,
                    0x94ef: 0x8cbb,
                    0x94f0: 0x907f,
                    0x94f1: 0x975e,
                    0x94f2: 0x98db,
                    0x94f3: 0x6a0b,
                    0x94f4: 0x7c38,
                    0x94f5: 0x5099,
                    0x94f6: 0x5c3e,
                    0x94f7: 0x5fae,
                    0x94f8: 0x6787,
                    0x94f9: 0x6bd8,
                    0x94fa: 0x7435,
                    0x94fb: 0x7709,
                    0x94fc: 0x7f8e,
                    0x9540: 0x9f3b,
                    0x9541: 0x67ca,
                    0x9542: 0x7a17,
                    0x9543: 0x5339,
                    0x9544: 0x758b,
                    0x9545: 0x9aed,
                    0x9546: 0x5f66,
                    0x9547: 0x819d,
                    0x9548: 0x83f1,
                    0x9549: 0x8098,
                    0x954a: 0x5f3c,
                    0x954b: 0x5fc5,
                    0x954c: 0x7562,
                    0x954d: 0x7b46,
                    0x954e: 0x903c,
                    0x954f: 0x6867,
                    0x9550: 0x59eb,
                    0x9551: 0x5a9b,
                    0x9552: 0x7d10,
                    0x9553: 0x767e,
                    0x9554: 0x8b2c,
                    0x9555: 0x4ff5,
                    0x9556: 0x5f6a,
                    0x9557: 0x6a19,
                    0x9558: 0x6c37,
                    0x9559: 0x6f02,
                    0x955a: 0x74e2,
                    0x955b: 0x7968,
                    0x955c: 0x8868,
                    0x955d: 0x8a55,
                    0x955e: 0x8c79,
                    0x955f: 0x5edf,
                    0x9560: 0x63cf,
                    0x9561: 0x75c5,
                    0x9562: 0x79d2,
                    0x9563: 0x82d7,
                    0x9564: 0x9328,
                    0x9565: 0x92f2,
                    0x9566: 0x849c,
                    0x9567: 0x86ed,
                    0x9568: 0x9c2d,
                    0x9569: 0x54c1,
                    0x956a: 0x5f6c,
                    0x956b: 0x658c,
                    0x956c: 0x6d5c,
                    0x956d: 0x7015,
                    0x956e: 0x8ca7,
                    0x956f: 0x8cd3,
                    0x9570: 0x983b,
                    0x9571: 0x654f,
                    0x9572: 0x74f6,
                    0x9573: 0x4e0d,
                    0x9574: 0x4ed8,
                    0x9575: 0x57e0,
                    0x9576: 0x592b,
                    0x9577: 0x5a66,
                    0x9578: 0x5bcc,
                    0x9579: 0x51a8,
                    0x957a: 0x5e03,
                    0x957b: 0x5e9c,
                    0x957c: 0x6016,
                    0x957d: 0x6276,
                    0x957e: 0x6577,
                    0x9580: 0x65a7,
                    0x9581: 0x666e,
                    0x9582: 0x6d6e,
                    0x9583: 0x7236,
                    0x9584: 0x7b26,
                    0x9585: 0x8150,
                    0x9586: 0x819a,
                    0x9587: 0x8299,
                    0x9588: 0x8b5c,
                    0x9589: 0x8ca0,
                    0x958a: 0x8ce6,
                    0x958b: 0x8d74,
                    0x958c: 0x961c,
                    0x958d: 0x9644,
                    0x958e: 0x4fae,
                    0x958f: 0x64ab,
                    0x9590: 0x6b66,
                    0x9591: 0x821e,
                    0x9592: 0x8461,
                    0x9593: 0x856a,
                    0x9594: 0x90e8,
                    0x9595: 0x5c01,
                    0x9596: 0x6953,
                    0x9597: 0x98a8,
                    0x9598: 0x847a,
                    0x9599: 0x8557,
                    0x959a: 0x4f0f,
                    0x959b: 0x526f,
                    0x959c: 0x5fa9,
                    0x959d: 0x5e45,
                    0x959e: 0x670d,
                    0x959f: 0x798f,
                    0x95a0: 0x8179,
                    0x95a1: 0x8907,
                    0x95a2: 0x8986,
                    0x95a3: 0x6df5,
                    0x95a4: 0x5f17,
                    0x95a5: 0x6255,
                    0x95a6: 0x6cb8,
                    0x95a7: 0x4ecf,
                    0x95a8: 0x7269,
                    0x95a9: 0x9b92,
                    0x95aa: 0x5206,
                    0x95ab: 0x543b,
                    0x95ac: 0x5674,
                    0x95ad: 0x58b3,
                    0x95ae: 0x61a4,
                    0x95af: 0x626e,
                    0x95b0: 0x711a,
                    0x95b1: 0x596e,
                    0x95b2: 0x7c89,
                    0x95b3: 0x7cde,
                    0x95b4: 0x7d1b,
                    0x95b5: 0x96f0,
                    0x95b6: 0x6587,
                    0x95b7: 0x805e,
                    0x95b8: 0x4e19,
                    0x95b9: 0x4f75,
                    0x95ba: 0x5175,
                    0x95bb: 0x5840,
                    0x95bc: 0x5e63,
                    0x95bd: 0x5e73,
                    0x95be: 0x5f0a,
                    0x95bf: 0x67c4,
                    0x95c0: 0x4e26,
                    0x95c1: 0x853d,
                    0x95c2: 0x9589,
                    0x95c3: 0x965b,
                    0x95c4: 0x7c73,
                    0x95c5: 0x9801,
                    0x95c6: 0x50fb,
                    0x95c7: 0x58c1,
                    0x95c8: 0x7656,
                    0x95c9: 0x78a7,
                    0x95ca: 0x5225,
                    0x95cb: 0x77a5,
                    0x95cc: 0x8511,
                    0x95cd: 0x7b86,
                    0x95ce: 0x504f,
                    0x95cf: 0x5909,
                    0x95d0: 0x7247,
                    0x95d1: 0x7bc7,
                    0x95d2: 0x7de8,
                    0x95d3: 0x8fba,
                    0x95d4: 0x8fd4,
                    0x95d5: 0x904d,
                    0x95d6: 0x4fbf,
                    0x95d7: 0x52c9,
                    0x95d8: 0x5a29,
                    0x95d9: 0x5f01,
                    0x95da: 0x97ad,
                    0x95db: 0x4fdd,
                    0x95dc: 0x8217,
                    0x95dd: 0x92ea,
                    0x95de: 0x5703,
                    0x95df: 0x6355,
                    0x95e0: 0x6b69,
                    0x95e1: 0x752b,
                    0x95e2: 0x88dc,
                    0x95e3: 0x8f14,
                    0x95e4: 0x7a42,
                    0x95e5: 0x52df,
                    0x95e6: 0x5893,
                    0x95e7: 0x6155,
                    0x95e8: 0x620a,
                    0x95e9: 0x66ae,
                    0x95ea: 0x6bcd,
                    0x95eb: 0x7c3f,
                    0x95ec: 0x83e9,
                    0x95ed: 0x5023,
                    0x95ee: 0x4ff8,
                    0x95ef: 0x5305,
                    0x95f0: 0x5446,
                    0x95f1: 0x5831,
                    0x95f2: 0x5949,
                    0x95f3: 0x5b9d,
                    0x95f4: 0x5cf0,
                    0x95f5: 0x5cef,
                    0x95f6: 0x5d29,
                    0x95f7: 0x5e96,
                    0x95f8: 0x62b1,
                    0x95f9: 0x6367,
                    0x95fa: 0x653e,
                    0x95fb: 0x65b9,
                    0x95fc: 0x670b,
                    0x9640: 0x6cd5,
                    0x9641: 0x6ce1,
                    0x9642: 0x70f9,
                    0x9643: 0x7832,
                    0x9644: 0x7e2b,
                    0x9645: 0x80de,
                    0x9646: 0x82b3,
                    0x9647: 0x840c,
                    0x9648: 0x84ec,
                    0x9649: 0x8702,
                    0x964a: 0x8912,
                    0x964b: 0x8a2a,
                    0x964c: 0x8c4a,
                    0x964d: 0x90a6,
                    0x964e: 0x92d2,
                    0x964f: 0x98fd,
                    0x9650: 0x9cf3,
                    0x9651: 0x9d6c,
                    0x9652: 0x4e4f,
                    0x9653: 0x4ea1,
                    0x9654: 0x508d,
                    0x9655: 0x5256,
                    0x9656: 0x574a,
                    0x9657: 0x59a8,
                    0x9658: 0x5e3d,
                    0x9659: 0x5fd8,
                    0x965a: 0x5fd9,
                    0x965b: 0x623f,
                    0x965c: 0x66b4,
                    0x965d: 0x671b,
                    0x965e: 0x67d0,
                    0x965f: 0x68d2,
                    0x9660: 0x5192,
                    0x9661: 0x7d21,
                    0x9662: 0x80aa,
                    0x9663: 0x81a8,
                    0x9664: 0x8b00,
                    0x9665: 0x8c8c,
                    0x9666: 0x8cbf,
                    0x9667: 0x927e,
                    0x9668: 0x9632,
                    0x9669: 0x5420,
                    0x966a: 0x982c,
                    0x966b: 0x5317,
                    0x966c: 0x50d5,
                    0x966d: 0x535c,
                    0x966e: 0x58a8,
                    0x966f: 0x64b2,
                    0x9670: 0x6734,
                    0x9671: 0x7267,
                    0x9672: 0x7766,
                    0x9673: 0x7a46,
                    0x9674: 0x91e6,
                    0x9675: 0x52c3,
                    0x9676: 0x6ca1,
                    0x9677: 0x6b86,
                    0x9678: 0x5800,
                    0x9679: 0x5e4c,
                    0x967a: 0x5954,
                    0x967b: 0x672c,
                    0x967c: 0x7ffb,
                    0x967d: 0x51e1,
                    0x967e: 0x76c6,
                    0x9680: 0x6469,
                    0x9681: 0x78e8,
                    0x9682: 0x9b54,
                    0x9683: 0x9ebb,
                    0x9684: 0x57cb,
                    0x9685: 0x59b9,
                    0x9686: 0x6627,
                    0x9687: 0x679a,
                    0x9688: 0x6bce,
                    0x9689: 0x54e9,
                    0x968a: 0x69d9,
                    0x968b: 0x5e55,
                    0x968c: 0x819c,
                    0x968d: 0x6795,
                    0x968e: 0x9baa,
                    0x968f: 0x67fe,
                    0x9690: 0x9c52,
                    0x9691: 0x685d,
                    0x9692: 0x4ea6,
                    0x9693: 0x4fe3,
                    0x9694: 0x53c8,
                    0x9695: 0x62b9,
                    0x9696: 0x672b,
                    0x9697: 0x6cab,
                    0x9698: 0x8fc4,
                    0x9699: 0x4fad,
                    0x969a: 0x7e6d,
                    0x969b: 0x9ebf,
                    0x969c: 0x4e07,
                    0x969d: 0x6162,
                    0x969e: 0x6e80,
                    0x969f: 0x6f2b,
                    0x96a0: 0x8513,
                    0x96a1: 0x5473,
                    0x96a2: 0x672a,
                    0x96a3: 0x9b45,
                    0x96a4: 0x5df3,
                    0x96a5: 0x7b95,
                    0x96a6: 0x5cac,
                    0x96a7: 0x5bc6,
                    0x96a8: 0x871c,
                    0x96a9: 0x6e4a,
                    0x96aa: 0x84d1,
                    0x96ab: 0x7a14,
                    0x96ac: 0x8108,
                    0x96ad: 0x5999,
                    0x96ae: 0x7c8d,
                    0x96af: 0x6c11,
                    0x96b0: 0x7720,
                    0x96b1: 0x52d9,
                    0x96b2: 0x5922,
                    0x96b3: 0x7121,
                    0x96b4: 0x725f,
                    0x96b5: 0x77db,
                    0x96b6: 0x9727,
                    0x96b7: 0x9d61,
                    0x96b8: 0x690b,
                    0x96b9: 0x5a7f,
                    0x96ba: 0x5a18,
                    0x96bb: 0x51a5,
                    0x96bc: 0x540d,
                    0x96bd: 0x547d,
                    0x96be: 0x660e,
                    0x96bf: 0x76df,
                    0x96c0: 0x8ff7,
                    0x96c1: 0x9298,
                    0x96c2: 0x9cf4,
                    0x96c3: 0x59ea,
                    0x96c4: 0x725d,
                    0x96c5: 0x6ec5,
                    0x96c6: 0x514d,
                    0x96c7: 0x68c9,
                    0x96c8: 0x7dbf,
                    0x96c9: 0x7dec,
                    0x96ca: 0x9762,
                    0x96cb: 0x9eba,
                    0x96cc: 0x6478,
                    0x96cd: 0x6a21,
                    0x96ce: 0x8302,
                    0x96cf: 0x5984,
                    0x96d0: 0x5b5f,
                    0x96d1: 0x6bdb,
                    0x96d2: 0x731b,
                    0x96d3: 0x76f2,
                    0x96d4: 0x7db2,
                    0x96d5: 0x8017,
                    0x96d6: 0x8499,
                    0x96d7: 0x5132,
                    0x96d8: 0x6728,
                    0x96d9: 0x9ed9,
                    0x96da: 0x76ee,
                    0x96db: 0x6762,
                    0x96dc: 0x52ff,
                    0x96dd: 0x9905,
                    0x96de: 0x5c24,
                    0x96df: 0x623b,
                    0x96e0: 0x7c7e,
                    0x96e1: 0x8cb0,
                    0x96e2: 0x554f,
                    0x96e3: 0x60b6,
                    0x96e4: 0x7d0b,
                    0x96e5: 0x9580,
                    0x96e6: 0x5301,
                    0x96e7: 0x4e5f,
                    0x96e8: 0x51b6,
                    0x96e9: 0x591c,
                    0x96ea: 0x723a,
                    0x96eb: 0x8036,
                    0x96ec: 0x91ce,
                    0x96ed: 0x5f25,
                    0x96ee: 0x77e2,
                    0x96ef: 0x5384,
                    0x96f0: 0x5f79,
                    0x96f1: 0x7d04,
                    0x96f2: 0x85ac,
                    0x96f3: 0x8a33,
                    0x96f4: 0x8e8d,
                    0x96f5: 0x9756,
                    0x96f6: 0x67f3,
                    0x96f7: 0x85ae,
                    0x96f8: 0x9453,
                    0x96f9: 0x6109,
                    0x96fa: 0x6108,
                    0x96fb: 0x6cb9,
                    0x96fc: 0x7652,
                    0x9740: 0x8aed,
                    0x9741: 0x8f38,
                    0x9742: 0x552f,
                    0x9743: 0x4f51,
                    0x9744: 0x512a,
                    0x9745: 0x52c7,
                    0x9746: 0x53cb,
                    0x9747: 0x5ba5,
                    0x9748: 0x5e7d,
                    0x9749: 0x60a0,
                    0x974a: 0x6182,
                    0x974b: 0x63d6,
                    0x974c: 0x6709,
                    0x974d: 0x67da,
                    0x974e: 0x6e67,
                    0x974f: 0x6d8c,
                    0x9750: 0x7336,
                    0x9751: 0x7337,
                    0x9752: 0x7531,
                    0x9753: 0x7950,
                    0x9754: 0x88d5,
                    0x9755: 0x8a98,
                    0x9756: 0x904a,
                    0x9757: 0x9091,
                    0x9758: 0x90f5,
                    0x9759: 0x96c4,
                    0x975a: 0x878d,
                    0x975b: 0x5915,
                    0x975c: 0x4e88,
                    0x975d: 0x4f59,
                    0x975e: 0x4e0e,
                    0x975f: 0x8a89,
                    0x9760: 0x8f3f,
                    0x9761: 0x9810,
                    0x9762: 0x50ad,
                    0x9763: 0x5e7c,
                    0x9764: 0x5996,
                    0x9765: 0x5bb9,
                    0x9766: 0x5eb8,
                    0x9767: 0x63da,
                    0x9768: 0x63fa,
                    0x9769: 0x64c1,
                    0x976a: 0x66dc,
                    0x976b: 0x694a,
                    0x976c: 0x69d8,
                    0x976d: 0x6d0b,
                    0x976e: 0x6eb6,
                    0x976f: 0x7194,
                    0x9770: 0x7528,
                    0x9771: 0x7aaf,
                    0x9772: 0x7f8a,
                    0x9773: 0x8000,
                    0x9774: 0x8449,
                    0x9775: 0x84c9,
                    0x9776: 0x8981,
                    0x9777: 0x8b21,
                    0x9778: 0x8e0a,
                    0x9779: 0x9065,
                    0x977a: 0x967d,
                    0x977b: 0x990a,
                    0x977c: 0x617e,
                    0x977d: 0x6291,
                    0x977e: 0x6b32,
                    0x9780: 0x6c83,
                    0x9781: 0x6d74,
                    0x9782: 0x7fcc,
                    0x9783: 0x7ffc,
                    0x9784: 0x6dc0,
                    0x9785: 0x7f85,
                    0x9786: 0x87ba,
                    0x9787: 0x88f8,
                    0x9788: 0x6765,
                    0x9789: 0x83b1,
                    0x978a: 0x983c,
                    0x978b: 0x96f7,
                    0x978c: 0x6d1b,
                    0x978d: 0x7d61,
                    0x978e: 0x843d,
                    0x978f: 0x916a,
                    0x9790: 0x4e71,
                    0x9791: 0x5375,
                    0x9792: 0x5d50,
                    0x9793: 0x6b04,
                    0x9794: 0x6feb,
                    0x9795: 0x85cd,
                    0x9796: 0x862d,
                    0x9797: 0x89a7,
                    0x9798: 0x5229,
                    0x9799: 0x540f,
                    0x979a: 0x5c65,
                    0x979b: 0x674e,
                    0x979c: 0x68a8,
                    0x979d: 0x7406,
                    0x979e: 0x7483,
                    0x979f: 0x75e2,
                    0x97a0: 0x88cf,
                    0x97a1: 0x88e1,
                    0x97a2: 0x91cc,
                    0x97a3: 0x96e2,
                    0x97a4: 0x9678,
                    0x97a5: 0x5f8b,
                    0x97a6: 0x7387,
                    0x97a7: 0x7acb,
                    0x97a8: 0x844e,
                    0x97a9: 0x63a0,
                    0x97aa: 0x7565,
                    0x97ab: 0x5289,
                    0x97ac: 0x6d41,
                    0x97ad: 0x6e9c,
                    0x97ae: 0x7409,
                    0x97af: 0x7559,
                    0x97b0: 0x786b,
                    0x97b1: 0x7c92,
                    0x97b2: 0x9686,
                    0x97b3: 0x7adc,
                    0x97b4: 0x9f8d,
                    0x97b5: 0x4fb6,
                    0x97b6: 0x616e,
                    0x97b7: 0x65c5,
                    0x97b8: 0x865c,
                    0x97b9: 0x4e86,
                    0x97ba: 0x4eae,
                    0x97bb: 0x50da,
                    0x97bc: 0x4e21,
                    0x97bd: 0x51cc,
                    0x97be: 0x5bee,
                    0x97bf: 0x6599,
                    0x97c0: 0x6881,
                    0x97c1: 0x6dbc,
                    0x97c2: 0x731f,
                    0x97c3: 0x7642,
                    0x97c4: 0x77ad,
                    0x97c5: 0x7a1c,
                    0x97c6: 0x7ce7,
                    0x97c7: 0x826f,
                    0x97c8: 0x8ad2,
                    0x97c9: 0x907c,
                    0x97ca: 0x91cf,
                    0x97cb: 0x9675,
                    0x97cc: 0x9818,
                    0x97cd: 0x529b,
                    0x97ce: 0x7dd1,
                    0x97cf: 0x502b,
                    0x97d0: 0x5398,
                    0x97d1: 0x6797,
                    0x97d2: 0x6dcb,
                    0x97d3: 0x71d0,
                    0x97d4: 0x7433,
                    0x97d5: 0x81e8,
                    0x97d6: 0x8f2a,
                    0x97d7: 0x96a3,
                    0x97d8: 0x9c57,
                    0x97d9: 0x9e9f,
                    0x97da: 0x7460,
                    0x97db: 0x5841,
                    0x97dc: 0x6d99,
                    0x97dd: 0x7d2f,
                    0x97de: 0x985e,
                    0x97df: 0x4ee4,
                    0x97e0: 0x4f36,
                    0x97e1: 0x4f8b,
                    0x97e2: 0x51b7,
                    0x97e3: 0x52b1,
                    0x97e4: 0x5dba,
                    0x97e5: 0x601c,
                    0x97e6: 0x73b2,
                    0x97e7: 0x793c,
                    0x97e8: 0x82d3,
                    0x97e9: 0x9234,
                    0x97ea: 0x96b7,
                    0x97eb: 0x96f6,
                    0x97ec: 0x970a,
                    0x97ed: 0x9e97,
                    0x97ee: 0x9f62,
                    0x97ef: 0x66a6,
                    0x97f0: 0x6b74,
                    0x97f1: 0x5217,
                    0x97f2: 0x52a3,
                    0x97f3: 0x70c8,
                    0x97f4: 0x88c2,
                    0x97f5: 0x5ec9,
                    0x97f6: 0x604b,
                    0x97f7: 0x6190,
                    0x97f8: 0x6f23,
                    0x97f9: 0x7149,
                    0x97fa: 0x7c3e,
                    0x97fb: 0x7df4,
                    0x97fc: 0x806f,
                    0x9840: 0x84ee,
                    0x9841: 0x9023,
                    0x9842: 0x932c,
                    0x9843: 0x5442,
                    0x9844: 0x9b6f,
                    0x9845: 0x6ad3,
                    0x9846: 0x7089,
                    0x9847: 0x8cc2,
                    0x9848: 0x8def,
                    0x9849: 0x9732,
                    0x984a: 0x52b4,
                    0x984b: 0x5a41,
                    0x984c: 0x5eca,
                    0x984d: 0x5f04,
                    0x984e: 0x6717,
                    0x984f: 0x697c,
                    0x9850: 0x6994,
                    0x9851: 0x6d6a,
                    0x9852: 0x6f0f,
                    0x9853: 0x7262,
                    0x9854: 0x72fc,
                    0x9855: 0x7bed,
                    0x9856: 0x8001,
                    0x9857: 0x807e,
                    0x9858: 0x874b,
                    0x9859: 0x90ce,
                    0x985a: 0x516d,
                    0x985b: 0x9e93,
                    0x985c: 0x7984,
                    0x985d: 0x808b,
                    0x985e: 0x9332,
                    0x985f: 0x8ad6,
                    0x9860: 0x502d,
                    0x9861: 0x548c,
                    0x9862: 0x8a71,
                    0x9863: 0x6b6a,
                    0x9864: 0x8cc4,
                    0x9865: 0x8107,
                    0x9866: 0x60d1,
                    0x9867: 0x67a0,
                    0x9868: 0x9df2,
                    0x9869: 0x4e99,
                    0x986a: 0x4e98,
                    0x986b: 0x9c10,
                    0x986c: 0x8a6b,
                    0x986d: 0x85c1,
                    0x986e: 0x8568,
                    0x986f: 0x6900,
                    0x9870: 0x6e7e,
                    0x9871: 0x7897,
                    0x9872: 0x8155,
                    0x989f: 0x5f0c,
                    0x98a0: 0x4e10,
                    0x98a1: 0x4e15,
                    0x98a2: 0x4e2a,
                    0x98a3: 0x4e31,
                    0x98a4: 0x4e36,
                    0x98a5: 0x4e3c,
                    0x98a6: 0x4e3f,
                    0x98a7: 0x4e42,
                    0x98a8: 0x4e56,
                    0x98a9: 0x4e58,
                    0x98aa: 0x4e82,
                    0x98ab: 0x4e85,
                    0x98ac: 0x8c6b,
                    0x98ad: 0x4e8a,
                    0x98ae: 0x8212,
                    0x98af: 0x5f0d,
                    0x98b0: 0x4e8e,
                    0x98b1: 0x4e9e,
                    0x98b2: 0x4e9f,
                    0x98b3: 0x4ea0,
                    0x98b4: 0x4ea2,
                    0x98b5: 0x4eb0,
                    0x98b6: 0x4eb3,
                    0x98b7: 0x4eb6,
                    0x98b8: 0x4ece,
                    0x98b9: 0x4ecd,
                    0x98ba: 0x4ec4,
                    0x98bb: 0x4ec6,
                    0x98bc: 0x4ec2,
                    0x98bd: 0x4ed7,
                    0x98be: 0x4ede,
                    0x98bf: 0x4eed,
                    0x98c0: 0x4edf,
                    0x98c1: 0x4ef7,
                    0x98c2: 0x4f09,
                    0x98c3: 0x4f5a,
                    0x98c4: 0x4f30,
                    0x98c5: 0x4f5b,
                    0x98c6: 0x4f5d,
                    0x98c7: 0x4f57,
                    0x98c8: 0x4f47,
                    0x98c9: 0x4f76,
                    0x98ca: 0x4f88,
                    0x98cb: 0x4f8f,
                    0x98cc: 0x4f98,
                    0x98cd: 0x4f7b,
                    0x98ce: 0x4f69,
                    0x98cf: 0x4f70,
                    0x98d0: 0x4f91,
                    0x98d1: 0x4f6f,
                    0x98d2: 0x4f86,
                    0x98d3: 0x4f96,
                    0x98d4: 0x5118,
                    0x98d5: 0x4fd4,
                    0x98d6: 0x4fdf,
                    0x98d7: 0x4fce,
                    0x98d8: 0x4fd8,
                    0x98d9: 0x4fdb,
                    0x98da: 0x4fd1,
                    0x98db: 0x4fda,
                    0x98dc: 0x4fd0,
                    0x98dd: 0x4fe4,
                    0x98de: 0x4fe5,
                    0x98df: 0x501a,
                    0x98e0: 0x5028,
                    0x98e1: 0x5014,
                    0x98e2: 0x502a,
                    0x98e3: 0x5025,
                    0x98e4: 0x5005,
                    0x98e5: 0x4f1c,
                    0x98e6: 0x4ff6,
                    0x98e7: 0x5021,
                    0x98e8: 0x5029,
                    0x98e9: 0x502c,
                    0x98ea: 0x4ffe,
                    0x98eb: 0x4fef,
                    0x98ec: 0x5011,
                    0x98ed: 0x5006,
                    0x98ee: 0x5043,
                    0x98ef: 0x5047,
                    0x98f0: 0x6703,
                    0x98f1: 0x5055,
                    0x98f2: 0x5050,
                    0x98f3: 0x5048,
                    0x98f4: 0x505a,
                    0x98f5: 0x5056,
                    0x98f6: 0x506c,
                    0x98f7: 0x5078,
                    0x98f8: 0x5080,
                    0x98f9: 0x509a,
                    0x98fa: 0x5085,
                    0x98fb: 0x50b4,
                    0x98fc: 0x50b2,
                    0x9940: 0x50c9,
                    0x9941: 0x50ca,
                    0x9942: 0x50b3,
                    0x9943: 0x50c2,
                    0x9944: 0x50d6,
                    0x9945: 0x50de,
                    0x9946: 0x50e5,
                    0x9947: 0x50ed,
                    0x9948: 0x50e3,
                    0x9949: 0x50ee,
                    0x994a: 0x50f9,
                    0x994b: 0x50f5,
                    0x994c: 0x5109,
                    0x994d: 0x5101,
                    0x994e: 0x5102,
                    0x994f: 0x5116,
                    0x9950: 0x5115,
                    0x9951: 0x5114,
                    0x9952: 0x511a,
                    0x9953: 0x5121,
                    0x9954: 0x513a,
                    0x9955: 0x5137,
                    0x9956: 0x513c,
                    0x9957: 0x513b,
                    0x9958: 0x513f,
                    0x9959: 0x5140,
                    0x995a: 0x5152,
                    0x995b: 0x514c,
                    0x995c: 0x5154,
                    0x995d: 0x5162,
                    0x995e: 0x7af8,
                    0x995f: 0x5169,
                    0x9960: 0x516a,
                    0x9961: 0x516e,
                    0x9962: 0x5180,
                    0x9963: 0x5182,
                    0x9964: 0x56d8,
                    0x9965: 0x518c,
                    0x9966: 0x5189,
                    0x9967: 0x518f,
                    0x9968: 0x5191,
                    0x9969: 0x5193,
                    0x996a: 0x5195,
                    0x996b: 0x5196,
                    0x996c: 0x51a4,
                    0x996d: 0x51a6,
                    0x996e: 0x51a2,
                    0x996f: 0x51a9,
                    0x9970: 0x51aa,
                    0x9971: 0x51ab,
                    0x9972: 0x51b3,
                    0x9973: 0x51b1,
                    0x9974: 0x51b2,
                    0x9975: 0x51b0,
                    0x9976: 0x51b5,
                    0x9977: 0x51bd,
                    0x9978: 0x51c5,
                    0x9979: 0x51c9,
                    0x997a: 0x51db,
                    0x997b: 0x51e0,
                    0x997c: 0x8655,
                    0x997d: 0x51e9,
                    0x997e: 0x51ed,
                    0x9980: 0x51f0,
                    0x9981: 0x51f5,
                    0x9982: 0x51fe,
                    0x9983: 0x5204,
                    0x9984: 0x520b,
                    0x9985: 0x5214,
                    0x9986: 0x520e,
                    0x9987: 0x5227,
                    0x9988: 0x522a,
                    0x9989: 0x522e,
                    0x998a: 0x5233,
                    0x998b: 0x5239,
                    0x998c: 0x524f,
                    0x998d: 0x5244,
                    0x998e: 0x524b,
                    0x998f: 0x524c,
                    0x9990: 0x525e,
                    0x9991: 0x5254,
                    0x9992: 0x526a,
                    0x9993: 0x5274,
                    0x9994: 0x5269,
                    0x9995: 0x5273,
                    0x9996: 0x527f,
                    0x9997: 0x527d,
                    0x9998: 0x528d,
                    0x9999: 0x5294,
                    0x999a: 0x5292,
                    0x999b: 0x5271,
                    0x999c: 0x5288,
                    0x999d: 0x5291,
                    0x999e: 0x8fa8,
                    0x999f: 0x8fa7,
                    0x99a0: 0x52ac,
                    0x99a1: 0x52ad,
                    0x99a2: 0x52bc,
                    0x99a3: 0x52b5,
                    0x99a4: 0x52c1,
                    0x99a5: 0x52cd,
                    0x99a6: 0x52d7,
                    0x99a7: 0x52de,
                    0x99a8: 0x52e3,
                    0x99a9: 0x52e6,
                    0x99aa: 0x98ed,
                    0x99ab: 0x52e0,
                    0x99ac: 0x52f3,
                    0x99ad: 0x52f5,
                    0x99ae: 0x52f8,
                    0x99af: 0x52f9,
                    0x99b0: 0x5306,
                    0x99b1: 0x5308,
                    0x99b2: 0x7538,
                    0x99b3: 0x530d,
                    0x99b4: 0x5310,
                    0x99b5: 0x530f,
                    0x99b6: 0x5315,
                    0x99b7: 0x531a,
                    0x99b8: 0x5323,
                    0x99b9: 0x532f,
                    0x99ba: 0x5331,
                    0x99bb: 0x5333,
                    0x99bc: 0x5338,
                    0x99bd: 0x5340,
                    0x99be: 0x5346,
                    0x99bf: 0x5345,
                    0x99c0: 0x4e17,
                    0x99c1: 0x5349,
                    0x99c2: 0x534d,
                    0x99c3: 0x51d6,
                    0x99c4: 0x535e,
                    0x99c5: 0x5369,
                    0x99c6: 0x536e,
                    0x99c7: 0x5918,
                    0x99c8: 0x537b,
                    0x99c9: 0x5377,
                    0x99ca: 0x5382,
                    0x99cb: 0x5396,
                    0x99cc: 0x53a0,
                    0x99cd: 0x53a6,
                    0x99ce: 0x53a5,
                    0x99cf: 0x53ae,
                    0x99d0: 0x53b0,
                    0x99d1: 0x53b6,
                    0x99d2: 0x53c3,
                    0x99d3: 0x7c12,
                    0x99d4: 0x96d9,
                    0x99d5: 0x53df,
                    0x99d6: 0x66fc,
                    0x99d7: 0x71ee,
                    0x99d8: 0x53ee,
                    0x99d9: 0x53e8,
                    0x99da: 0x53ed,
                    0x99db: 0x53fa,
                    0x99dc: 0x5401,
                    0x99dd: 0x543d,
                    0x99de: 0x5440,
                    0x99df: 0x542c,
                    0x99e0: 0x542d,
                    0x99e1: 0x543c,
                    0x99e2: 0x542e,
                    0x99e3: 0x5436,
                    0x99e4: 0x5429,
                    0x99e5: 0x541d,
                    0x99e6: 0x544e,
                    0x99e7: 0x548f,
                    0x99e8: 0x5475,
                    0x99e9: 0x548e,
                    0x99ea: 0x545f,
                    0x99eb: 0x5471,
                    0x99ec: 0x5477,
                    0x99ed: 0x5470,
                    0x99ee: 0x5492,
                    0x99ef: 0x547b,
                    0x99f0: 0x5480,
                    0x99f1: 0x5476,
                    0x99f2: 0x5484,
                    0x99f3: 0x5490,
                    0x99f4: 0x5486,
                    0x99f5: 0x54c7,
                    0x99f6: 0x54a2,
                    0x99f7: 0x54b8,
                    0x99f8: 0x54a5,
                    0x99f9: 0x54ac,
                    0x99fa: 0x54c4,
                    0x99fb: 0x54c8,
                    0x99fc: 0x54a8,
                    0x9a40: 0x54ab,
                    0x9a41: 0x54c2,
                    0x9a42: 0x54a4,
                    0x9a43: 0x54be,
                    0x9a44: 0x54bc,
                    0x9a45: 0x54d8,
                    0x9a46: 0x54e5,
                    0x9a47: 0x54e6,
                    0x9a48: 0x550f,
                    0x9a49: 0x5514,
                    0x9a4a: 0x54fd,
                    0x9a4b: 0x54ee,
                    0x9a4c: 0x54ed,
                    0x9a4d: 0x54fa,
                    0x9a4e: 0x54e2,
                    0x9a4f: 0x5539,
                    0x9a50: 0x5540,
                    0x9a51: 0x5563,
                    0x9a52: 0x554c,
                    0x9a53: 0x552e,
                    0x9a54: 0x555c,
                    0x9a55: 0x5545,
                    0x9a56: 0x5556,
                    0x9a57: 0x5557,
                    0x9a58: 0x5538,
                    0x9a59: 0x5533,
                    0x9a5a: 0x555d,
                    0x9a5b: 0x5599,
                    0x9a5c: 0x5580,
                    0x9a5d: 0x54af,
                    0x9a5e: 0x558a,
                    0x9a5f: 0x559f,
                    0x9a60: 0x557b,
                    0x9a61: 0x557e,
                    0x9a62: 0x5598,
                    0x9a63: 0x559e,
                    0x9a64: 0x55ae,
                    0x9a65: 0x557c,
                    0x9a66: 0x5583,
                    0x9a67: 0x55a9,
                    0x9a68: 0x5587,
                    0x9a69: 0x55a8,
                    0x9a6a: 0x55da,
                    0x9a6b: 0x55c5,
                    0x9a6c: 0x55df,
                    0x9a6d: 0x55c4,
                    0x9a6e: 0x55dc,
                    0x9a6f: 0x55e4,
                    0x9a70: 0x55d4,
                    0x9a71: 0x5614,
                    0x9a72: 0x55f7,
                    0x9a73: 0x5616,
                    0x9a74: 0x55fe,
                    0x9a75: 0x55fd,
                    0x9a76: 0x561b,
                    0x9a77: 0x55f9,
                    0x9a78: 0x564e,
                    0x9a79: 0x5650,
                    0x9a7a: 0x71df,
                    0x9a7b: 0x5634,
                    0x9a7c: 0x5636,
                    0x9a7d: 0x5632,
                    0x9a7e: 0x5638,
                    0x9a80: 0x566b,
                    0x9a81: 0x5664,
                    0x9a82: 0x562f,
                    0x9a83: 0x566c,
                    0x9a84: 0x566a,
                    0x9a85: 0x5686,
                    0x9a86: 0x5680,
                    0x9a87: 0x568a,
                    0x9a88: 0x56a0,
                    0x9a89: 0x5694,
                    0x9a8a: 0x568f,
                    0x9a8b: 0x56a5,
                    0x9a8c: 0x56ae,
                    0x9a8d: 0x56b6,
                    0x9a8e: 0x56b4,
                    0x9a8f: 0x56c2,
                    0x9a90: 0x56bc,
                    0x9a91: 0x56c1,
                    0x9a92: 0x56c3,
                    0x9a93: 0x56c0,
                    0x9a94: 0x56c8,
                    0x9a95: 0x56ce,
                    0x9a96: 0x56d1,
                    0x9a97: 0x56d3,
                    0x9a98: 0x56d7,
                    0x9a99: 0x56ee,
                    0x9a9a: 0x56f9,
                    0x9a9b: 0x5700,
                    0x9a9c: 0x56ff,
                    0x9a9d: 0x5704,
                    0x9a9e: 0x5709,
                    0x9a9f: 0x5708,
                    0x9aa0: 0x570b,
                    0x9aa1: 0x570d,
                    0x9aa2: 0x5713,
                    0x9aa3: 0x5718,
                    0x9aa4: 0x5716,
                    0x9aa5: 0x55c7,
                    0x9aa6: 0x571c,
                    0x9aa7: 0x5726,
                    0x9aa8: 0x5737,
                    0x9aa9: 0x5738,
                    0x9aaa: 0x574e,
                    0x9aab: 0x573b,
                    0x9aac: 0x5740,
                    0x9aad: 0x574f,
                    0x9aae: 0x5769,
                    0x9aaf: 0x57c0,
                    0x9ab0: 0x5788,
                    0x9ab1: 0x5761,
                    0x9ab2: 0x577f,
                    0x9ab3: 0x5789,
                    0x9ab4: 0x5793,
                    0x9ab5: 0x57a0,
                    0x9ab6: 0x57b3,
                    0x9ab7: 0x57a4,
                    0x9ab8: 0x57aa,
                    0x9ab9: 0x57b0,
                    0x9aba: 0x57c3,
                    0x9abb: 0x57c6,
                    0x9abc: 0x57d4,
                    0x9abd: 0x57d2,
                    0x9abe: 0x57d3,
                    0x9abf: 0x580a,
                    0x9ac0: 0x57d6,
                    0x9ac1: 0x57e3,
                    0x9ac2: 0x580b,
                    0x9ac3: 0x5819,
                    0x9ac4: 0x581d,
                    0x9ac5: 0x5872,
                    0x9ac6: 0x5821,
                    0x9ac7: 0x5862,
                    0x9ac8: 0x584b,
                    0x9ac9: 0x5870,
                    0x9aca: 0x6bc0,
                    0x9acb: 0x5852,
                    0x9acc: 0x583d,
                    0x9acd: 0x5879,
                    0x9ace: 0x5885,
                    0x9acf: 0x58b9,
                    0x9ad0: 0x589f,
                    0x9ad1: 0x58ab,
                    0x9ad2: 0x58ba,
                    0x9ad3: 0x58de,
                    0x9ad4: 0x58bb,
                    0x9ad5: 0x58b8,
                    0x9ad6: 0x58ae,
                    0x9ad7: 0x58c5,
                    0x9ad8: 0x58d3,
                    0x9ad9: 0x58d1,
                    0x9ada: 0x58d7,
                    0x9adb: 0x58d9,
                    0x9adc: 0x58d8,
                    0x9add: 0x58e5,
                    0x9ade: 0x58dc,
                    0x9adf: 0x58e4,
                    0x9ae0: 0x58df,
                    0x9ae1: 0x58ef,
                    0x9ae2: 0x58fa,
                    0x9ae3: 0x58f9,
                    0x9ae4: 0x58fb,
                    0x9ae5: 0x58fc,
                    0x9ae6: 0x58fd,
                    0x9ae7: 0x5902,
                    0x9ae8: 0x590a,
                    0x9ae9: 0x5910,
                    0x9aea: 0x591b,
                    0x9aeb: 0x68a6,
                    0x9aec: 0x5925,
                    0x9aed: 0x592c,
                    0x9aee: 0x592d,
                    0x9aef: 0x5932,
                    0x9af0: 0x5938,
                    0x9af1: 0x593e,
                    0x9af2: 0x7ad2,
                    0x9af3: 0x5955,
                    0x9af4: 0x5950,
                    0x9af5: 0x594e,
                    0x9af6: 0x595a,
                    0x9af7: 0x5958,
                    0x9af8: 0x5962,
                    0x9af9: 0x5960,
                    0x9afa: 0x5967,
                    0x9afb: 0x596c,
                    0x9afc: 0x5969,
                    0x9b40: 0x5978,
                    0x9b41: 0x5981,
                    0x9b42: 0x599d,
                    0x9b43: 0x4f5e,
                    0x9b44: 0x4fab,
                    0x9b45: 0x59a3,
                    0x9b46: 0x59b2,
                    0x9b47: 0x59c6,
                    0x9b48: 0x59e8,
                    0x9b49: 0x59dc,
                    0x9b4a: 0x598d,
                    0x9b4b: 0x59d9,
                    0x9b4c: 0x59da,
                    0x9b4d: 0x5a25,
                    0x9b4e: 0x5a1f,
                    0x9b4f: 0x5a11,
                    0x9b50: 0x5a1c,
                    0x9b51: 0x5a09,
                    0x9b52: 0x5a1a,
                    0x9b53: 0x5a40,
                    0x9b54: 0x5a6c,
                    0x9b55: 0x5a49,
                    0x9b56: 0x5a35,
                    0x9b57: 0x5a36,
                    0x9b58: 0x5a62,
                    0x9b59: 0x5a6a,
                    0x9b5a: 0x5a9a,
                    0x9b5b: 0x5abc,
                    0x9b5c: 0x5abe,
                    0x9b5d: 0x5acb,
                    0x9b5e: 0x5ac2,
                    0x9b5f: 0x5abd,
                    0x9b60: 0x5ae3,
                    0x9b61: 0x5ad7,
                    0x9b62: 0x5ae6,
                    0x9b63: 0x5ae9,
                    0x9b64: 0x5ad6,
                    0x9b65: 0x5afa,
                    0x9b66: 0x5afb,
                    0x9b67: 0x5b0c,
                    0x9b68: 0x5b0b,
                    0x9b69: 0x5b16,
                    0x9b6a: 0x5b32,
                    0x9b6b: 0x5ad0,
                    0x9b6c: 0x5b2a,
                    0x9b6d: 0x5b36,
                    0x9b6e: 0x5b3e,
                    0x9b6f: 0x5b43,
                    0x9b70: 0x5b45,
                    0x9b71: 0x5b40,
                    0x9b72: 0x5b51,
                    0x9b73: 0x5b55,
                    0x9b74: 0x5b5a,
                    0x9b75: 0x5b5b,
                    0x9b76: 0x5b65,
                    0x9b77: 0x5b69,
                    0x9b78: 0x5b70,
                    0x9b79: 0x5b73,
                    0x9b7a: 0x5b75,
                    0x9b7b: 0x5b78,
                    0x9b7c: 0x6588,
                    0x9b7d: 0x5b7a,
                    0x9b7e: 0x5b80,
                    0x9b80: 0x5b83,
                    0x9b81: 0x5ba6,
                    0x9b82: 0x5bb8,
                    0x9b83: 0x5bc3,
                    0x9b84: 0x5bc7,
                    0x9b85: 0x5bc9,
                    0x9b86: 0x5bd4,
                    0x9b87: 0x5bd0,
                    0x9b88: 0x5be4,
                    0x9b89: 0x5be6,
                    0x9b8a: 0x5be2,
                    0x9b8b: 0x5bde,
                    0x9b8c: 0x5be5,
                    0x9b8d: 0x5beb,
                    0x9b8e: 0x5bf0,
                    0x9b8f: 0x5bf6,
                    0x9b90: 0x5bf3,
                    0x9b91: 0x5c05,
                    0x9b92: 0x5c07,
                    0x9b93: 0x5c08,
                    0x9b94: 0x5c0d,
                    0x9b95: 0x5c13,
                    0x9b96: 0x5c20,
                    0x9b97: 0x5c22,
                    0x9b98: 0x5c28,
                    0x9b99: 0x5c38,
                    0x9b9a: 0x5c39,
                    0x9b9b: 0x5c41,
                    0x9b9c: 0x5c46,
                    0x9b9d: 0x5c4e,
                    0x9b9e: 0x5c53,
                    0x9b9f: 0x5c50,
                    0x9ba0: 0x5c4f,
                    0x9ba1: 0x5b71,
                    0x9ba2: 0x5c6c,
                    0x9ba3: 0x5c6e,
                    0x9ba4: 0x4e62,
                    0x9ba5: 0x5c76,
                    0x9ba6: 0x5c79,
                    0x9ba7: 0x5c8c,
                    0x9ba8: 0x5c91,
                    0x9ba9: 0x5c94,
                    0x9baa: 0x599b,
                    0x9bab: 0x5cab,
                    0x9bac: 0x5cbb,
                    0x9bad: 0x5cb6,
                    0x9bae: 0x5cbc,
                    0x9baf: 0x5cb7,
                    0x9bb0: 0x5cc5,
                    0x9bb1: 0x5cbe,
                    0x9bb2: 0x5cc7,
                    0x9bb3: 0x5cd9,
                    0x9bb4: 0x5ce9,
                    0x9bb5: 0x5cfd,
                    0x9bb6: 0x5cfa,
                    0x9bb7: 0x5ced,
                    0x9bb8: 0x5d8c,
                    0x9bb9: 0x5cea,
                    0x9bba: 0x5d0b,
                    0x9bbb: 0x5d15,
                    0x9bbc: 0x5d17,
                    0x9bbd: 0x5d5c,
                    0x9bbe: 0x5d1f,
                    0x9bbf: 0x5d1b,
                    0x9bc0: 0x5d11,
                    0x9bc1: 0x5d14,
                    0x9bc2: 0x5d22,
                    0x9bc3: 0x5d1a,
                    0x9bc4: 0x5d19,
                    0x9bc5: 0x5d18,
                    0x9bc6: 0x5d4c,
                    0x9bc7: 0x5d52,
                    0x9bc8: 0x5d4e,
                    0x9bc9: 0x5d4b,
                    0x9bca: 0x5d6c,
                    0x9bcb: 0x5d73,
                    0x9bcc: 0x5d76,
                    0x9bcd: 0x5d87,
                    0x9bce: 0x5d84,
                    0x9bcf: 0x5d82,
                    0x9bd0: 0x5da2,
                    0x9bd1: 0x5d9d,
                    0x9bd2: 0x5dac,
                    0x9bd3: 0x5dae,
                    0x9bd4: 0x5dbd,
                    0x9bd5: 0x5d90,
                    0x9bd6: 0x5db7,
                    0x9bd7: 0x5dbc,
                    0x9bd8: 0x5dc9,
                    0x9bd9: 0x5dcd,
                    0x9bda: 0x5dd3,
                    0x9bdb: 0x5dd2,
                    0x9bdc: 0x5dd6,
                    0x9bdd: 0x5ddb,
                    0x9bde: 0x5deb,
                    0x9bdf: 0x5df2,
                    0x9be0: 0x5df5,
                    0x9be1: 0x5e0b,
                    0x9be2: 0x5e1a,
                    0x9be3: 0x5e19,
                    0x9be4: 0x5e11,
                    0x9be5: 0x5e1b,
                    0x9be6: 0x5e36,
                    0x9be7: 0x5e37,
                    0x9be8: 0x5e44,
                    0x9be9: 0x5e43,
                    0x9bea: 0x5e40,
                    0x9beb: 0x5e4e,
                    0x9bec: 0x5e57,
                    0x9bed: 0x5e54,
                    0x9bee: 0x5e5f,
                    0x9bef: 0x5e62,
                    0x9bf0: 0x5e64,
                    0x9bf1: 0x5e47,
                    0x9bf2: 0x5e75,
                    0x9bf3: 0x5e76,
                    0x9bf4: 0x5e7a,
                    0x9bf5: 0x9ebc,
                    0x9bf6: 0x5e7f,
                    0x9bf7: 0x5ea0,
                    0x9bf8: 0x5ec1,
                    0x9bf9: 0x5ec2,
                    0x9bfa: 0x5ec8,
                    0x9bfb: 0x5ed0,
                    0x9bfc: 0x5ecf,
                    0x9c40: 0x5ed6,
                    0x9c41: 0x5ee3,
                    0x9c42: 0x5edd,
                    0x9c43: 0x5eda,
                    0x9c44: 0x5edb,
                    0x9c45: 0x5ee2,
                    0x9c46: 0x5ee1,
                    0x9c47: 0x5ee8,
                    0x9c48: 0x5ee9,
                    0x9c49: 0x5eec,
                    0x9c4a: 0x5ef1,
                    0x9c4b: 0x5ef3,
                    0x9c4c: 0x5ef0,
                    0x9c4d: 0x5ef4,
                    0x9c4e: 0x5ef8,
                    0x9c4f: 0x5efe,
                    0x9c50: 0x5f03,
                    0x9c51: 0x5f09,
                    0x9c52: 0x5f5d,
                    0x9c53: 0x5f5c,
                    0x9c54: 0x5f0b,
                    0x9c55: 0x5f11,
                    0x9c56: 0x5f16,
                    0x9c57: 0x5f29,
                    0x9c58: 0x5f2d,
                    0x9c59: 0x5f38,
                    0x9c5a: 0x5f41,
                    0x9c5b: 0x5f48,
                    0x9c5c: 0x5f4c,
                    0x9c5d: 0x5f4e,
                    0x9c5e: 0x5f2f,
                    0x9c5f: 0x5f51,
                    0x9c60: 0x5f56,
                    0x9c61: 0x5f57,
                    0x9c62: 0x5f59,
                    0x9c63: 0x5f61,
                    0x9c64: 0x5f6d,
                    0x9c65: 0x5f73,
                    0x9c66: 0x5f77,
                    0x9c67: 0x5f83,
                    0x9c68: 0x5f82,
                    0x9c69: 0x5f7f,
                    0x9c6a: 0x5f8a,
                    0x9c6b: 0x5f88,
                    0x9c6c: 0x5f91,
                    0x9c6d: 0x5f87,
                    0x9c6e: 0x5f9e,
                    0x9c6f: 0x5f99,
                    0x9c70: 0x5f98,
                    0x9c71: 0x5fa0,
                    0x9c72: 0x5fa8,
                    0x9c73: 0x5fad,
                    0x9c74: 0x5fbc,
                    0x9c75: 0x5fd6,
                    0x9c76: 0x5ffb,
                    0x9c77: 0x5fe4,
                    0x9c78: 0x5ff8,
                    0x9c79: 0x5ff1,
                    0x9c7a: 0x5fdd,
                    0x9c7b: 0x60b3,
                    0x9c7c: 0x5fff,
                    0x9c7d: 0x6021,
                    0x9c7e: 0x6060,
                    0x9c80: 0x6019,
                    0x9c81: 0x6010,
                    0x9c82: 0x6029,
                    0x9c83: 0x600e,
                    0x9c84: 0x6031,
                    0x9c85: 0x601b,
                    0x9c86: 0x6015,
                    0x9c87: 0x602b,
                    0x9c88: 0x6026,
                    0x9c89: 0x600f,
                    0x9c8a: 0x603a,
                    0x9c8b: 0x605a,
                    0x9c8c: 0x6041,
                    0x9c8d: 0x606a,
                    0x9c8e: 0x6077,
                    0x9c8f: 0x605f,
                    0x9c90: 0x604a,
                    0x9c91: 0x6046,
                    0x9c92: 0x604d,
                    0x9c93: 0x6063,
                    0x9c94: 0x6043,
                    0x9c95: 0x6064,
                    0x9c96: 0x6042,
                    0x9c97: 0x606c,
                    0x9c98: 0x606b,
                    0x9c99: 0x6059,
                    0x9c9a: 0x6081,
                    0x9c9b: 0x608d,
                    0x9c9c: 0x60e7,
                    0x9c9d: 0x6083,
                    0x9c9e: 0x609a,
                    0x9c9f: 0x6084,
                    0x9ca0: 0x609b,
                    0x9ca1: 0x6096,
                    0x9ca2: 0x6097,
                    0x9ca3: 0x6092,
                    0x9ca4: 0x60a7,
                    0x9ca5: 0x608b,
                    0x9ca6: 0x60e1,
                    0x9ca7: 0x60b8,
                    0x9ca8: 0x60e0,
                    0x9ca9: 0x60d3,
                    0x9caa: 0x60b4,
                    0x9cab: 0x5ff0,
                    0x9cac: 0x60bd,
                    0x9cad: 0x60c6,
                    0x9cae: 0x60b5,
                    0x9caf: 0x60d8,
                    0x9cb0: 0x614d,
                    0x9cb1: 0x6115,
                    0x9cb2: 0x6106,
                    0x9cb3: 0x60f6,
                    0x9cb4: 0x60f7,
                    0x9cb5: 0x6100,
                    0x9cb6: 0x60f4,
                    0x9cb7: 0x60fa,
                    0x9cb8: 0x6103,
                    0x9cb9: 0x6121,
                    0x9cba: 0x60fb,
                    0x9cbb: 0x60f1,
                    0x9cbc: 0x610d,
                    0x9cbd: 0x610e,
                    0x9cbe: 0x6147,
                    0x9cbf: 0x613e,
                    0x9cc0: 0x6128,
                    0x9cc1: 0x6127,
                    0x9cc2: 0x614a,
                    0x9cc3: 0x613f,
                    0x9cc4: 0x613c,
                    0x9cc5: 0x612c,
                    0x9cc6: 0x6134,
                    0x9cc7: 0x613d,
                    0x9cc8: 0x6142,
                    0x9cc9: 0x6144,
                    0x9cca: 0x6173,
                    0x9ccb: 0x6177,
                    0x9ccc: 0x6158,
                    0x9ccd: 0x6159,
                    0x9cce: 0x615a,
                    0x9ccf: 0x616b,
                    0x9cd0: 0x6174,
                    0x9cd1: 0x616f,
                    0x9cd2: 0x6165,
                    0x9cd3: 0x6171,
                    0x9cd4: 0x615f,
                    0x9cd5: 0x615d,
                    0x9cd6: 0x6153,
                    0x9cd7: 0x6175,
                    0x9cd8: 0x6199,
                    0x9cd9: 0x6196,
                    0x9cda: 0x6187,
                    0x9cdb: 0x61ac,
                    0x9cdc: 0x6194,
                    0x9cdd: 0x619a,
                    0x9cde: 0x618a,
                    0x9cdf: 0x6191,
                    0x9ce0: 0x61ab,
                    0x9ce1: 0x61ae,
                    0x9ce2: 0x61cc,
                    0x9ce3: 0x61ca,
                    0x9ce4: 0x61c9,
                    0x9ce5: 0x61f7,
                    0x9ce6: 0x61c8,
                    0x9ce7: 0x61c3,
                    0x9ce8: 0x61c6,
                    0x9ce9: 0x61ba,
                    0x9cea: 0x61cb,
                    0x9ceb: 0x7f79,
                    0x9cec: 0x61cd,
                    0x9ced: 0x61e6,
                    0x9cee: 0x61e3,
                    0x9cef: 0x61f6,
                    0x9cf0: 0x61fa,
                    0x9cf1: 0x61f4,
                    0x9cf2: 0x61ff,
                    0x9cf3: 0x61fd,
                    0x9cf4: 0x61fc,
                    0x9cf5: 0x61fe,
                    0x9cf6: 0x6200,
                    0x9cf7: 0x6208,
                    0x9cf8: 0x6209,
                    0x9cf9: 0x620d,
                    0x9cfa: 0x620c,
                    0x9cfb: 0x6214,
                    0x9cfc: 0x621b,
                    0x9d40: 0x621e,
                    0x9d41: 0x6221,
                    0x9d42: 0x622a,
                    0x9d43: 0x622e,
                    0x9d44: 0x6230,
                    0x9d45: 0x6232,
                    0x9d46: 0x6233,
                    0x9d47: 0x6241,
                    0x9d48: 0x624e,
                    0x9d49: 0x625e,
                    0x9d4a: 0x6263,
                    0x9d4b: 0x625b,
                    0x9d4c: 0x6260,
                    0x9d4d: 0x6268,
                    0x9d4e: 0x627c,
                    0x9d4f: 0x6282,
                    0x9d50: 0x6289,
                    0x9d51: 0x627e,
                    0x9d52: 0x6292,
                    0x9d53: 0x6293,
                    0x9d54: 0x6296,
                    0x9d55: 0x62d4,
                    0x9d56: 0x6283,
                    0x9d57: 0x6294,
                    0x9d58: 0x62d7,
                    0x9d59: 0x62d1,
                    0x9d5a: 0x62bb,
                    0x9d5b: 0x62cf,
                    0x9d5c: 0x62ff,
                    0x9d5d: 0x62c6,
                    0x9d5e: 0x64d4,
                    0x9d5f: 0x62c8,
                    0x9d60: 0x62dc,
                    0x9d61: 0x62cc,
                    0x9d62: 0x62ca,
                    0x9d63: 0x62c2,
                    0x9d64: 0x62c7,
                    0x9d65: 0x629b,
                    0x9d66: 0x62c9,
                    0x9d67: 0x630c,
                    0x9d68: 0x62ee,
                    0x9d69: 0x62f1,
                    0x9d6a: 0x6327,
                    0x9d6b: 0x6302,
                    0x9d6c: 0x6308,
                    0x9d6d: 0x62ef,
                    0x9d6e: 0x62f5,
                    0x9d6f: 0x6350,
                    0x9d70: 0x633e,
                    0x9d71: 0x634d,
                    0x9d72: 0x641c,
                    0x9d73: 0x634f,
                    0x9d74: 0x6396,
                    0x9d75: 0x638e,
                    0x9d76: 0x6380,
                    0x9d77: 0x63ab,
                    0x9d78: 0x6376,
                    0x9d79: 0x63a3,
                    0x9d7a: 0x638f,
                    0x9d7b: 0x6389,
                    0x9d7c: 0x639f,
                    0x9d7d: 0x63b5,
                    0x9d7e: 0x636b,
                    0x9d80: 0x6369,
                    0x9d81: 0x63be,
                    0x9d82: 0x63e9,
                    0x9d83: 0x63c0,
                    0x9d84: 0x63c6,
                    0x9d85: 0x63e3,
                    0x9d86: 0x63c9,
                    0x9d87: 0x63d2,
                    0x9d88: 0x63f6,
                    0x9d89: 0x63c4,
                    0x9d8a: 0x6416,
                    0x9d8b: 0x6434,
                    0x9d8c: 0x6406,
                    0x9d8d: 0x6413,
                    0x9d8e: 0x6426,
                    0x9d8f: 0x6436,
                    0x9d90: 0x651d,
                    0x9d91: 0x6417,
                    0x9d92: 0x6428,
                    0x9d93: 0x640f,
                    0x9d94: 0x6467,
                    0x9d95: 0x646f,
                    0x9d96: 0x6476,
                    0x9d97: 0x644e,
                    0x9d98: 0x652a,
                    0x9d99: 0x6495,
                    0x9d9a: 0x6493,
                    0x9d9b: 0x64a5,
                    0x9d9c: 0x64a9,
                    0x9d9d: 0x6488,
                    0x9d9e: 0x64bc,
                    0x9d9f: 0x64da,
                    0x9da0: 0x64d2,
                    0x9da1: 0x64c5,
                    0x9da2: 0x64c7,
                    0x9da3: 0x64bb,
                    0x9da4: 0x64d8,
                    0x9da5: 0x64c2,
                    0x9da6: 0x64f1,
                    0x9da7: 0x64e7,
                    0x9da8: 0x8209,
                    0x9da9: 0x64e0,
                    0x9daa: 0x64e1,
                    0x9dab: 0x62ac,
                    0x9dac: 0x64e3,
                    0x9dad: 0x64ef,
                    0x9dae: 0x652c,
                    0x9daf: 0x64f6,
                    0x9db0: 0x64f4,
                    0x9db1: 0x64f2,
                    0x9db2: 0x64fa,
                    0x9db3: 0x6500,
                    0x9db4: 0x64fd,
                    0x9db5: 0x6518,
                    0x9db6: 0x651c,
                    0x9db7: 0x6505,
                    0x9db8: 0x6524,
                    0x9db9: 0x6523,
                    0x9dba: 0x652b,
                    0x9dbb: 0x6534,
                    0x9dbc: 0x6535,
                    0x9dbd: 0x6537,
                    0x9dbe: 0x6536,
                    0x9dbf: 0x6538,
                    0x9dc0: 0x754b,
                    0x9dc1: 0x6548,
                    0x9dc2: 0x6556,
                    0x9dc3: 0x6555,
                    0x9dc4: 0x654d,
                    0x9dc5: 0x6558,
                    0x9dc6: 0x655e,
                    0x9dc7: 0x655d,
                    0x9dc8: 0x6572,
                    0x9dc9: 0x6578,
                    0x9dca: 0x6582,
                    0x9dcb: 0x6583,
                    0x9dcc: 0x8b8a,
                    0x9dcd: 0x659b,
                    0x9dce: 0x659f,
                    0x9dcf: 0x65ab,
                    0x9dd0: 0x65b7,
                    0x9dd1: 0x65c3,
                    0x9dd2: 0x65c6,
                    0x9dd3: 0x65c1,
                    0x9dd4: 0x65c4,
                    0x9dd5: 0x65cc,
                    0x9dd6: 0x65d2,
                    0x9dd7: 0x65db,
                    0x9dd8: 0x65d9,
                    0x9dd9: 0x65e0,
                    0x9dda: 0x65e1,
                    0x9ddb: 0x65f1,
                    0x9ddc: 0x6772,
                    0x9ddd: 0x660a,
                    0x9dde: 0x6603,
                    0x9ddf: 0x65fb,
                    0x9de0: 0x6773,
                    0x9de1: 0x6635,
                    0x9de2: 0x6636,
                    0x9de3: 0x6634,
                    0x9de4: 0x661c,
                    0x9de5: 0x664f,
                    0x9de6: 0x6644,
                    0x9de7: 0x6649,
                    0x9de8: 0x6641,
                    0x9de9: 0x665e,
                    0x9dea: 0x665d,
                    0x9deb: 0x6664,
                    0x9dec: 0x6667,
                    0x9ded: 0x6668,
                    0x9dee: 0x665f,
                    0x9def: 0x6662,
                    0x9df0: 0x6670,
                    0x9df1: 0x6683,
                    0x9df2: 0x6688,
                    0x9df3: 0x668e,
                    0x9df4: 0x6689,
                    0x9df5: 0x6684,
                    0x9df6: 0x6698,
                    0x9df7: 0x669d,
                    0x9df8: 0x66c1,
                    0x9df9: 0x66b9,
                    0x9dfa: 0x66c9,
                    0x9dfb: 0x66be,
                    0x9dfc: 0x66bc,
                    0x9e40: 0x66c4,
                    0x9e41: 0x66b8,
                    0x9e42: 0x66d6,
                    0x9e43: 0x66da,
                    0x9e44: 0x66e0,
                    0x9e45: 0x663f,
                    0x9e46: 0x66e6,
                    0x9e47: 0x66e9,
                    0x9e48: 0x66f0,
                    0x9e49: 0x66f5,
                    0x9e4a: 0x66f7,
                    0x9e4b: 0x670f,
                    0x9e4c: 0x6716,
                    0x9e4d: 0x671e,
                    0x9e4e: 0x6726,
                    0x9e4f: 0x6727,
                    0x9e50: 0x9738,
                    0x9e51: 0x672e,
                    0x9e52: 0x673f,
                    0x9e53: 0x6736,
                    0x9e54: 0x6741,
                    0x9e55: 0x6738,
                    0x9e56: 0x6737,
                    0x9e57: 0x6746,
                    0x9e58: 0x675e,
                    0x9e59: 0x6760,
                    0x9e5a: 0x6759,
                    0x9e5b: 0x6763,
                    0x9e5c: 0x6764,
                    0x9e5d: 0x6789,
                    0x9e5e: 0x6770,
                    0x9e5f: 0x67a9,
                    0x9e60: 0x677c,
                    0x9e61: 0x676a,
                    0x9e62: 0x678c,
                    0x9e63: 0x678b,
                    0x9e64: 0x67a6,
                    0x9e65: 0x67a1,
                    0x9e66: 0x6785,
                    0x9e67: 0x67b7,
                    0x9e68: 0x67ef,
                    0x9e69: 0x67b4,
                    0x9e6a: 0x67ec,
                    0x9e6b: 0x67b3,
                    0x9e6c: 0x67e9,
                    0x9e6d: 0x67b8,
                    0x9e6e: 0x67e4,
                    0x9e6f: 0x67de,
                    0x9e70: 0x67dd,
                    0x9e71: 0x67e2,
                    0x9e72: 0x67ee,
                    0x9e73: 0x67b9,
                    0x9e74: 0x67ce,
                    0x9e75: 0x67c6,
                    0x9e76: 0x67e7,
                    0x9e77: 0x6a9c,
                    0x9e78: 0x681e,
                    0x9e79: 0x6846,
                    0x9e7a: 0x6829,
                    0x9e7b: 0x6840,
                    0x9e7c: 0x684d,
                    0x9e7d: 0x6832,
                    0x9e7e: 0x684e,
                    0x9e80: 0x68b3,
                    0x9e81: 0x682b,
                    0x9e82: 0x6859,
                    0x9e83: 0x6863,
                    0x9e84: 0x6877,
                    0x9e85: 0x687f,
                    0x9e86: 0x689f,
                    0x9e87: 0x688f,
                    0x9e88: 0x68ad,
                    0x9e89: 0x6894,
                    0x9e8a: 0x689d,
                    0x9e8b: 0x689b,
                    0x9e8c: 0x6883,
                    0x9e8d: 0x6aae,
                    0x9e8e: 0x68b9,
                    0x9e8f: 0x6874,
                    0x9e90: 0x68b5,
                    0x9e91: 0x68a0,
                    0x9e92: 0x68ba,
                    0x9e93: 0x690f,
                    0x9e94: 0x688d,
                    0x9e95: 0x687e,
                    0x9e96: 0x6901,
                    0x9e97: 0x68ca,
                    0x9e98: 0x6908,
                    0x9e99: 0x68d8,
                    0x9e9a: 0x6922,
                    0x9e9b: 0x6926,
                    0x9e9c: 0x68e1,
                    0x9e9d: 0x690c,
                    0x9e9e: 0x68cd,
                    0x9e9f: 0x68d4,
                    0x9ea0: 0x68e7,
                    0x9ea1: 0x68d5,
                    0x9ea2: 0x6936,
                    0x9ea3: 0x6912,
                    0x9ea4: 0x6904,
                    0x9ea5: 0x68d7,
                    0x9ea6: 0x68e3,
                    0x9ea7: 0x6925,
                    0x9ea8: 0x68f9,
                    0x9ea9: 0x68e0,
                    0x9eaa: 0x68ef,
                    0x9eab: 0x6928,
                    0x9eac: 0x692a,
                    0x9ead: 0x691a,
                    0x9eae: 0x6923,
                    0x9eaf: 0x6921,
                    0x9eb0: 0x68c6,
                    0x9eb1: 0x6979,
                    0x9eb2: 0x6977,
                    0x9eb3: 0x695c,
                    0x9eb4: 0x6978,
                    0x9eb5: 0x696b,
                    0x9eb6: 0x6954,
                    0x9eb7: 0x697e,
                    0x9eb8: 0x696e,
                    0x9eb9: 0x6939,
                    0x9eba: 0x6974,
                    0x9ebb: 0x693d,
                    0x9ebc: 0x6959,
                    0x9ebd: 0x6930,
                    0x9ebe: 0x6961,
                    0x9ebf: 0x695e,
                    0x9ec0: 0x695d,
                    0x9ec1: 0x6981,
                    0x9ec2: 0x696a,
                    0x9ec3: 0x69b2,
                    0x9ec4: 0x69ae,
                    0x9ec5: 0x69d0,
                    0x9ec6: 0x69bf,
                    0x9ec7: 0x69c1,
                    0x9ec8: 0x69d3,
                    0x9ec9: 0x69be,
                    0x9eca: 0x69ce,
                    0x9ecb: 0x5be8,
                    0x9ecc: 0x69ca,
                    0x9ecd: 0x69dd,
                    0x9ece: 0x69bb,
                    0x9ecf: 0x69c3,
                    0x9ed0: 0x69a7,
                    0x9ed1: 0x6a2e,
                    0x9ed2: 0x6991,
                    0x9ed3: 0x69a0,
                    0x9ed4: 0x699c,
                    0x9ed5: 0x6995,
                    0x9ed6: 0x69b4,
                    0x9ed7: 0x69de,
                    0x9ed8: 0x69e8,
                    0x9ed9: 0x6a02,
                    0x9eda: 0x6a1b,
                    0x9edb: 0x69ff,
                    0x9edc: 0x6b0a,
                    0x9edd: 0x69f9,
                    0x9ede: 0x69f2,
                    0x9edf: 0x69e7,
                    0x9ee0: 0x6a05,
                    0x9ee1: 0x69b1,
                    0x9ee2: 0x6a1e,
                    0x9ee3: 0x69ed,
                    0x9ee4: 0x6a14,
                    0x9ee5: 0x69eb,
                    0x9ee6: 0x6a0a,
                    0x9ee7: 0x6a12,
                    0x9ee8: 0x6ac1,
                    0x9ee9: 0x6a23,
                    0x9eea: 0x6a13,
                    0x9eeb: 0x6a44,
                    0x9eec: 0x6a0c,
                    0x9eed: 0x6a72,
                    0x9eee: 0x6a36,
                    0x9eef: 0x6a78,
                    0x9ef0: 0x6a47,
                    0x9ef1: 0x6a62,
                    0x9ef2: 0x6a59,
                    0x9ef3: 0x6a66,
                    0x9ef4: 0x6a48,
                    0x9ef5: 0x6a38,
                    0x9ef6: 0x6a22,
                    0x9ef7: 0x6a90,
                    0x9ef8: 0x6a8d,
                    0x9ef9: 0x6aa0,
                    0x9efa: 0x6a84,
                    0x9efb: 0x6aa2,
                    0x9efc: 0x6aa3,
                    0x9f40: 0x6a97,
                    0x9f41: 0x8617,
                    0x9f42: 0x6abb,
                    0x9f43: 0x6ac3,
                    0x9f44: 0x6ac2,
                    0x9f45: 0x6ab8,
                    0x9f46: 0x6ab3,
                    0x9f47: 0x6aac,
                    0x9f48: 0x6ade,
                    0x9f49: 0x6ad1,
                    0x9f4a: 0x6adf,
                    0x9f4b: 0x6aaa,
                    0x9f4c: 0x6ada,
                    0x9f4d: 0x6aea,
                    0x9f4e: 0x6afb,
                    0x9f4f: 0x6b05,
                    0x9f50: 0x8616,
                    0x9f51: 0x6afa,
                    0x9f52: 0x6b12,
                    0x9f53: 0x6b16,
                    0x9f54: 0x9b31,
                    0x9f55: 0x6b1f,
                    0x9f56: 0x6b38,
                    0x9f57: 0x6b37,
                    0x9f58: 0x76dc,
                    0x9f59: 0x6b39,
                    0x9f5a: 0x98ee,
                    0x9f5b: 0x6b47,
                    0x9f5c: 0x6b43,
                    0x9f5d: 0x6b49,
                    0x9f5e: 0x6b50,
                    0x9f5f: 0x6b59,
                    0x9f60: 0x6b54,
                    0x9f61: 0x6b5b,
                    0x9f62: 0x6b5f,
                    0x9f63: 0x6b61,
                    0x9f64: 0x6b78,
                    0x9f65: 0x6b79,
                    0x9f66: 0x6b7f,
                    0x9f67: 0x6b80,
                    0x9f68: 0x6b84,
                    0x9f69: 0x6b83,
                    0x9f6a: 0x6b8d,
                    0x9f6b: 0x6b98,
                    0x9f6c: 0x6b95,
                    0x9f6d: 0x6b9e,
                    0x9f6e: 0x6ba4,
                    0x9f6f: 0x6baa,
                    0x9f70: 0x6bab,
                    0x9f71: 0x6baf,
                    0x9f72: 0x6bb2,
                    0x9f73: 0x6bb1,
                    0x9f74: 0x6bb3,
                    0x9f75: 0x6bb7,
                    0x9f76: 0x6bbc,
                    0x9f77: 0x6bc6,
                    0x9f78: 0x6bcb,
                    0x9f79: 0x6bd3,
                    0x9f7a: 0x6bdf,
                    0x9f7b: 0x6bec,
                    0x9f7c: 0x6beb,
                    0x9f7d: 0x6bf3,
                    0x9f7e: 0x6bef,
                    0x9f80: 0x9ebe,
                    0x9f81: 0x6c08,
                    0x9f82: 0x6c13,
                    0x9f83: 0x6c14,
                    0x9f84: 0x6c1b,
                    0x9f85: 0x6c24,
                    0x9f86: 0x6c23,
                    0x9f87: 0x6c5e,
                    0x9f88: 0x6c55,
                    0x9f89: 0x6c62,
                    0x9f8a: 0x6c6a,
                    0x9f8b: 0x6c82,
                    0x9f8c: 0x6c8d,
                    0x9f8d: 0x6c9a,
                    0x9f8e: 0x6c81,
                    0x9f8f: 0x6c9b,
                    0x9f90: 0x6c7e,
                    0x9f91: 0x6c68,
                    0x9f92: 0x6c73,
                    0x9f93: 0x6c92,
                    0x9f94: 0x6c90,
                    0x9f95: 0x6cc4,
                    0x9f96: 0x6cf1,
                    0x9f97: 0x6cd3,
                    0x9f98: 0x6cbd,
                    0x9f99: 0x6cd7,
                    0x9f9a: 0x6cc5,
                    0x9f9b: 0x6cdd,
                    0x9f9c: 0x6cae,
                    0x9f9d: 0x6cb1,
                    0x9f9e: 0x6cbe,
                    0x9f9f: 0x6cba,
                    0x9fa0: 0x6cdb,
                    0x9fa1: 0x6cef,
                    0x9fa2: 0x6cd9,
                    0x9fa3: 0x6cea,
                    0x9fa4: 0x6d1f,
                    0x9fa5: 0x884d,
                    0x9fa6: 0x6d36,
                    0x9fa7: 0x6d2b,
                    0x9fa8: 0x6d3d,
                    0x9fa9: 0x6d38,
                    0x9faa: 0x6d19,
                    0x9fab: 0x6d35,
                    0x9fac: 0x6d33,
                    0x9fad: 0x6d12,
                    0x9fae: 0x6d0c,
                    0x9faf: 0x6d63,
                    0x9fb0: 0x6d93,
                    0x9fb1: 0x6d64,
                    0x9fb2: 0x6d5a,
                    0x9fb3: 0x6d79,
                    0x9fb4: 0x6d59,
                    0x9fb5: 0x6d8e,
                    0x9fb6: 0x6d95,
                    0x9fb7: 0x6fe4,
                    0x9fb8: 0x6d85,
                    0x9fb9: 0x6df9,
                    0x9fba: 0x6e15,
                    0x9fbb: 0x6e0a,
                    0x9fbc: 0x6db5,
                    0x9fbd: 0x6dc7,
                    0x9fbe: 0x6de6,
                    0x9fbf: 0x6db8,
                    0x9fc0: 0x6dc6,
                    0x9fc1: 0x6dec,
                    0x9fc2: 0x6dde,
                    0x9fc3: 0x6dcc,
                    0x9fc4: 0x6de8,
                    0x9fc5: 0x6dd2,
                    0x9fc6: 0x6dc5,
                    0x9fc7: 0x6dfa,
                    0x9fc8: 0x6dd9,
                    0x9fc9: 0x6de4,
                    0x9fca: 0x6dd5,
                    0x9fcb: 0x6dea,
                    0x9fcc: 0x6dee,
                    0x9fcd: 0x6e2d,
                    0x9fce: 0x6e6e,
                    0x9fcf: 0x6e2e,
                    0x9fd0: 0x6e19,
                    0x9fd1: 0x6e72,
                    0x9fd2: 0x6e5f,
                    0x9fd3: 0x6e3e,
                    0x9fd4: 0x6e23,
                    0x9fd5: 0x6e6b,
                    0x9fd6: 0x6e2b,
                    0x9fd7: 0x6e76,
                    0x9fd8: 0x6e4d,
                    0x9fd9: 0x6e1f,
                    0x9fda: 0x6e43,
                    0x9fdb: 0x6e3a,
                    0x9fdc: 0x6e4e,
                    0x9fdd: 0x6e24,
                    0x9fde: 0x6eff,
                    0x9fdf: 0x6e1d,
                    0x9fe0: 0x6e38,
                    0x9fe1: 0x6e82,
                    0x9fe2: 0x6eaa,
                    0x9fe3: 0x6e98,
                    0x9fe4: 0x6ec9,
                    0x9fe5: 0x6eb7,
                    0x9fe6: 0x6ed3,
                    0x9fe7: 0x6ebd,
                    0x9fe8: 0x6eaf,
                    0x9fe9: 0x6ec4,
                    0x9fea: 0x6eb2,
                    0x9feb: 0x6ed4,
                    0x9fec: 0x6ed5,
                    0x9fed: 0x6e8f,
                    0x9fee: 0x6ea5,
                    0x9fef: 0x6ec2,
                    0x9ff0: 0x6e9f,
                    0x9ff1: 0x6f41,
                    0x9ff2: 0x6f11,
                    0x9ff3: 0x704c,
                    0x9ff4: 0x6eec,
                    0x9ff5: 0x6ef8,
                    0x9ff6: 0x6efe,
                    0x9ff7: 0x6f3f,
                    0x9ff8: 0x6ef2,
                    0x9ff9: 0x6f31,
                    0x9ffa: 0x6eef,
                    0x9ffb: 0x6f32,
                    0x9ffc: 0x6ecc,
                    0xa1: 0xff61,
                    0xa2: 0xff62,
                    0xa3: 0xff63,
                    0xa4: 0xff64,
                    0xa5: 0xff65,
                    0xa6: 0xff66,
                    0xa7: 0xff67,
                    0xa8: 0xff68,
                    0xa9: 0xff69,
                    0xaa: 0xff6a,
                    0xab: 0xff6b,
                    0xac: 0xff6c,
                    0xad: 0xff6d,
                    0xae: 0xff6e,
                    0xaf: 0xff6f,
                    0xb0: 0xff70,
                    0xb1: 0xff71,
                    0xb2: 0xff72,
                    0xb3: 0xff73,
                    0xb4: 0xff74,
                    0xb5: 0xff75,
                    0xb6: 0xff76,
                    0xb7: 0xff77,
                    0xb8: 0xff78,
                    0xb9: 0xff79,
                    0xba: 0xff7a,
                    0xbb: 0xff7b,
                    0xbc: 0xff7c,
                    0xbd: 0xff7d,
                    0xbe: 0xff7e,
                    0xbf: 0xff7f,
                    0xc0: 0xff80,
                    0xc1: 0xff81,
                    0xc2: 0xff82,
                    0xc3: 0xff83,
                    0xc4: 0xff84,
                    0xc5: 0xff85,
                    0xc6: 0xff86,
                    0xc7: 0xff87,
                    0xc8: 0xff88,
                    0xc9: 0xff89,
                    0xca: 0xff8a,
                    0xcb: 0xff8b,
                    0xcc: 0xff8c,
                    0xcd: 0xff8d,
                    0xce: 0xff8e,
                    0xcf: 0xff8f,
                    0xd0: 0xff90,
                    0xd1: 0xff91,
                    0xd2: 0xff92,
                    0xd3: 0xff93,
                    0xd4: 0xff94,
                    0xd5: 0xff95,
                    0xd6: 0xff96,
                    0xd7: 0xff97,
                    0xd8: 0xff98,
                    0xd9: 0xff99,
                    0xda: 0xff9a,
                    0xdb: 0xff9b,
                    0xdc: 0xff9c,
                    0xdd: 0xff9d,
                    0xde: 0xff9e,
                    0xdf: 0xff9f,
                    0xe040: 0x6f3e,
                    0xe041: 0x6f13,
                    0xe042: 0x6ef7,
                    0xe043: 0x6f86,
                    0xe044: 0x6f7a,
                    0xe045: 0x6f78,
                    0xe046: 0x6f81,
                    0xe047: 0x6f80,
                    0xe048: 0x6f6f,
                    0xe049: 0x6f5b,
                    0xe04a: 0x6ff3,
                    0xe04b: 0x6f6d,
                    0xe04c: 0x6f82,
                    0xe04d: 0x6f7c,
                    0xe04e: 0x6f58,
                    0xe04f: 0x6f8e,
                    0xe050: 0x6f91,
                    0xe051: 0x6fc2,
                    0xe052: 0x6f66,
                    0xe053: 0x6fb3,
                    0xe054: 0x6fa3,
                    0xe055: 0x6fa1,
                    0xe056: 0x6fa4,
                    0xe057: 0x6fb9,
                    0xe058: 0x6fc6,
                    0xe059: 0x6faa,
                    0xe05a: 0x6fdf,
                    0xe05b: 0x6fd5,
                    0xe05c: 0x6fec,
                    0xe05d: 0x6fd4,
                    0xe05e: 0x6fd8,
                    0xe05f: 0x6ff1,
                    0xe060: 0x6fee,
                    0xe061: 0x6fdb,
                    0xe062: 0x7009,
                    0xe063: 0x700b,
                    0xe064: 0x6ffa,
                    0xe065: 0x7011,
                    0xe066: 0x7001,
                    0xe067: 0x700f,
                    0xe068: 0x6ffe,
                    0xe069: 0x701b,
                    0xe06a: 0x701a,
                    0xe06b: 0x6f74,
                    0xe06c: 0x701d,
                    0xe06d: 0x7018,
                    0xe06e: 0x701f,
                    0xe06f: 0x7030,
                    0xe070: 0x703e,
                    0xe071: 0x7032,
                    0xe072: 0x7051,
                    0xe073: 0x7063,
                    0xe074: 0x7099,
                    0xe075: 0x7092,
                    0xe076: 0x70af,
                    0xe077: 0x70f1,
                    0xe078: 0x70ac,
                    0xe079: 0x70b8,
                    0xe07a: 0x70b3,
                    0xe07b: 0x70ae,
                    0xe07c: 0x70df,
                    0xe07d: 0x70cb,
                    0xe07e: 0x70dd,
                    0xe080: 0x70d9,
                    0xe081: 0x7109,
                    0xe082: 0x70fd,
                    0xe083: 0x711c,
                    0xe084: 0x7119,
                    0xe085: 0x7165,
                    0xe086: 0x7155,
                    0xe087: 0x7188,
                    0xe088: 0x7166,
                    0xe089: 0x7162,
                    0xe08a: 0x714c,
                    0xe08b: 0x7156,
                    0xe08c: 0x716c,
                    0xe08d: 0x718f,
                    0xe08e: 0x71fb,
                    0xe08f: 0x7184,
                    0xe090: 0x7195,
                    0xe091: 0x71a8,
                    0xe092: 0x71ac,
                    0xe093: 0x71d7,
                    0xe094: 0x71b9,
                    0xe095: 0x71be,
                    0xe096: 0x71d2,
                    0xe097: 0x71c9,
                    0xe098: 0x71d4,
                    0xe099: 0x71ce,
                    0xe09a: 0x71e0,
                    0xe09b: 0x71ec,
                    0xe09c: 0x71e7,
                    0xe09d: 0x71f5,
                    0xe09e: 0x71fc,
                    0xe09f: 0x71f9,
                    0xe0a0: 0x71ff,
                    0xe0a1: 0x720d,
                    0xe0a2: 0x7210,
                    0xe0a3: 0x721b,
                    0xe0a4: 0x7228,
                    0xe0a5: 0x722d,
                    0xe0a6: 0x722c,
                    0xe0a7: 0x7230,
                    0xe0a8: 0x7232,
                    0xe0a9: 0x723b,
                    0xe0aa: 0x723c,
                    0xe0ab: 0x723f,
                    0xe0ac: 0x7240,
                    0xe0ad: 0x7246,
                    0xe0ae: 0x724b,
                    0xe0af: 0x7258,
                    0xe0b0: 0x7274,
                    0xe0b1: 0x727e,
                    0xe0b2: 0x7282,
                    0xe0b3: 0x7281,
                    0xe0b4: 0x7287,
                    0xe0b5: 0x7292,
                    0xe0b6: 0x7296,
                    0xe0b7: 0x72a2,
                    0xe0b8: 0x72a7,
                    0xe0b9: 0x72b9,
                    0xe0ba: 0x72b2,
                    0xe0bb: 0x72c3,
                    0xe0bc: 0x72c6,
                    0xe0bd: 0x72c4,
                    0xe0be: 0x72ce,
                    0xe0bf: 0x72d2,
                    0xe0c0: 0x72e2,
                    0xe0c1: 0x72e0,
                    0xe0c2: 0x72e1,
                    0xe0c3: 0x72f9,
                    0xe0c4: 0x72f7,
                    0xe0c5: 0x500f,
                    0xe0c6: 0x7317,
                    0xe0c7: 0x730a,
                    0xe0c8: 0x731c,
                    0xe0c9: 0x7316,
                    0xe0ca: 0x731d,
                    0xe0cb: 0x7334,
                    0xe0cc: 0x732f,
                    0xe0cd: 0x7329,
                    0xe0ce: 0x7325,
                    0xe0cf: 0x733e,
                    0xe0d0: 0x734e,
                    0xe0d1: 0x734f,
                    0xe0d2: 0x9ed8,
                    0xe0d3: 0x7357,
                    0xe0d4: 0x736a,
                    0xe0d5: 0x7368,
                    0xe0d6: 0x7370,
                    0xe0d7: 0x7378,
                    0xe0d8: 0x7375,
                    0xe0d9: 0x737b,
                    0xe0da: 0x737a,
                    0xe0db: 0x73c8,
                    0xe0dc: 0x73b3,
                    0xe0dd: 0x73ce,
                    0xe0de: 0x73bb,
                    0xe0df: 0x73c0,
                    0xe0e0: 0x73e5,
                    0xe0e1: 0x73ee,
                    0xe0e2: 0x73de,
                    0xe0e3: 0x74a2,
                    0xe0e4: 0x7405,
                    0xe0e5: 0x746f,
                    0xe0e6: 0x7425,
                    0xe0e7: 0x73f8,
                    0xe0e8: 0x7432,
                    0xe0e9: 0x743a,
                    0xe0ea: 0x7455,
                    0xe0eb: 0x743f,
                    0xe0ec: 0x745f,
                    0xe0ed: 0x7459,
                    0xe0ee: 0x7441,
                    0xe0ef: 0x745c,
                    0xe0f0: 0x7469,
                    0xe0f1: 0x7470,
                    0xe0f2: 0x7463,
                    0xe0f3: 0x746a,
                    0xe0f4: 0x7476,
                    0xe0f5: 0x747e,
                    0xe0f6: 0x748b,
                    0xe0f7: 0x749e,
                    0xe0f8: 0x74a7,
                    0xe0f9: 0x74ca,
                    0xe0fa: 0x74cf,
                    0xe0fb: 0x74d4,
                    0xe0fc: 0x73f1,
                    0xe140: 0x74e0,
                    0xe141: 0x74e3,
                    0xe142: 0x74e7,
                    0xe143: 0x74e9,
                    0xe144: 0x74ee,
                    0xe145: 0x74f2,
                    0xe146: 0x74f0,
                    0xe147: 0x74f1,
                    0xe148: 0x74f8,
                    0xe149: 0x74f7,
                    0xe14a: 0x7504,
                    0xe14b: 0x7503,
                    0xe14c: 0x7505,
                    0xe14d: 0x750c,
                    0xe14e: 0x750e,
                    0xe14f: 0x750d,
                    0xe150: 0x7515,
                    0xe151: 0x7513,
                    0xe152: 0x751e,
                    0xe153: 0x7526,
                    0xe154: 0x752c,
                    0xe155: 0x753c,
                    0xe156: 0x7544,
                    0xe157: 0x754d,
                    0xe158: 0x754a,
                    0xe159: 0x7549,
                    0xe15a: 0x755b,
                    0xe15b: 0x7546,
                    0xe15c: 0x755a,
                    0xe15d: 0x7569,
                    0xe15e: 0x7564,
                    0xe15f: 0x7567,
                    0xe160: 0x756b,
                    0xe161: 0x756d,
                    0xe162: 0x7578,
                    0xe163: 0x7576,
                    0xe164: 0x7586,
                    0xe165: 0x7587,
                    0xe166: 0x7574,
                    0xe167: 0x758a,
                    0xe168: 0x7589,
                    0xe169: 0x7582,
                    0xe16a: 0x7594,
                    0xe16b: 0x759a,
                    0xe16c: 0x759d,
                    0xe16d: 0x75a5,
                    0xe16e: 0x75a3,
                    0xe16f: 0x75c2,
                    0xe170: 0x75b3,
                    0xe171: 0x75c3,
                    0xe172: 0x75b5,
                    0xe173: 0x75bd,
                    0xe174: 0x75b8,
                    0xe175: 0x75bc,
                    0xe176: 0x75b1,
                    0xe177: 0x75cd,
                    0xe178: 0x75ca,
                    0xe179: 0x75d2,
                    0xe17a: 0x75d9,
                    0xe17b: 0x75e3,
                    0xe17c: 0x75de,
                    0xe17d: 0x75fe,
                    0xe17e: 0x75ff,
                    0xe180: 0x75fc,
                    0xe181: 0x7601,
                    0xe182: 0x75f0,
                    0xe183: 0x75fa,
                    0xe184: 0x75f2,
                    0xe185: 0x75f3,
                    0xe186: 0x760b,
                    0xe187: 0x760d,
                    0xe188: 0x7609,
                    0xe189: 0x761f,
                    0xe18a: 0x7627,
                    0xe18b: 0x7620,
                    0xe18c: 0x7621,
                    0xe18d: 0x7622,
                    0xe18e: 0x7624,
                    0xe18f: 0x7634,
                    0xe190: 0x7630,
                    0xe191: 0x763b,
                    0xe192: 0x7647,
                    0xe193: 0x7648,
                    0xe194: 0x7646,
                    0xe195: 0x765c,
                    0xe196: 0x7658,
                    0xe197: 0x7661,
                    0xe198: 0x7662,
                    0xe199: 0x7668,
                    0xe19a: 0x7669,
                    0xe19b: 0x766a,
                    0xe19c: 0x7667,
                    0xe19d: 0x766c,
                    0xe19e: 0x7670,
                    0xe19f: 0x7672,
                    0xe1a0: 0x7676,
                    0xe1a1: 0x7678,
                    0xe1a2: 0x767c,
                    0xe1a3: 0x7680,
                    0xe1a4: 0x7683,
                    0xe1a5: 0x7688,
                    0xe1a6: 0x768b,
                    0xe1a7: 0x768e,
                    0xe1a8: 0x7696,
                    0xe1a9: 0x7693,
                    0xe1aa: 0x7699,
                    0xe1ab: 0x769a,
                    0xe1ac: 0x76b0,
                    0xe1ad: 0x76b4,
                    0xe1ae: 0x76b8,
                    0xe1af: 0x76b9,
                    0xe1b0: 0x76ba,
                    0xe1b1: 0x76c2,
                    0xe1b2: 0x76cd,
                    0xe1b3: 0x76d6,
                    0xe1b4: 0x76d2,
                    0xe1b5: 0x76de,
                    0xe1b6: 0x76e1,
                    0xe1b7: 0x76e5,
                    0xe1b8: 0x76e7,
                    0xe1b9: 0x76ea,
                    0xe1ba: 0x862f,
                    0xe1bb: 0x76fb,
                    0xe1bc: 0x7708,
                    0xe1bd: 0x7707,
                    0xe1be: 0x7704,
                    0xe1bf: 0x7729,
                    0xe1c0: 0x7724,
                    0xe1c1: 0x771e,
                    0xe1c2: 0x7725,
                    0xe1c3: 0x7726,
                    0xe1c4: 0x771b,
                    0xe1c5: 0x7737,
                    0xe1c6: 0x7738,
                    0xe1c7: 0x7747,
                    0xe1c8: 0x775a,
                    0xe1c9: 0x7768,
                    0xe1ca: 0x776b,
                    0xe1cb: 0x775b,
                    0xe1cc: 0x7765,
                    0xe1cd: 0x777f,
                    0xe1ce: 0x777e,
                    0xe1cf: 0x7779,
                    0xe1d0: 0x778e,
                    0xe1d1: 0x778b,
                    0xe1d2: 0x7791,
                    0xe1d3: 0x77a0,
                    0xe1d4: 0x779e,
                    0xe1d5: 0x77b0,
                    0xe1d6: 0x77b6,
                    0xe1d7: 0x77b9,
                    0xe1d8: 0x77bf,
                    0xe1d9: 0x77bc,
                    0xe1da: 0x77bd,
                    0xe1db: 0x77bb,
                    0xe1dc: 0x77c7,
                    0xe1dd: 0x77cd,
                    0xe1de: 0x77d7,
                    0xe1df: 0x77da,
                    0xe1e0: 0x77dc,
                    0xe1e1: 0x77e3,
                    0xe1e2: 0x77ee,
                    0xe1e3: 0x77fc,
                    0xe1e4: 0x780c,
                    0xe1e5: 0x7812,
                    0xe1e6: 0x7926,
                    0xe1e7: 0x7820,
                    0xe1e8: 0x792a,
                    0xe1e9: 0x7845,
                    0xe1ea: 0x788e,
                    0xe1eb: 0x7874,
                    0xe1ec: 0x7886,
                    0xe1ed: 0x787c,
                    0xe1ee: 0x789a,
                    0xe1ef: 0x788c,
                    0xe1f0: 0x78a3,
                    0xe1f1: 0x78b5,
                    0xe1f2: 0x78aa,
                    0xe1f3: 0x78af,
                    0xe1f4: 0x78d1,
                    0xe1f5: 0x78c6,
                    0xe1f6: 0x78cb,
                    0xe1f7: 0x78d4,
                    0xe1f8: 0x78be,
                    0xe1f9: 0x78bc,
                    0xe1fa: 0x78c5,
                    0xe1fb: 0x78ca,
                    0xe1fc: 0x78ec,
                    0xe240: 0x78e7,
                    0xe241: 0x78da,
                    0xe242: 0x78fd,
                    0xe243: 0x78f4,
                    0xe244: 0x7907,
                    0xe245: 0x7912,
                    0xe246: 0x7911,
                    0xe247: 0x7919,
                    0xe248: 0x792c,
                    0xe249: 0x792b,
                    0xe24a: 0x7940,
                    0xe24b: 0x7960,
                    0xe24c: 0x7957,
                    0xe24d: 0x795f,
                    0xe24e: 0x795a,
                    0xe24f: 0x7955,
                    0xe250: 0x7953,
                    0xe251: 0x797a,
                    0xe252: 0x797f,
                    0xe253: 0x798a,
                    0xe254: 0x799d,
                    0xe255: 0x79a7,
                    0xe256: 0x9f4b,
                    0xe257: 0x79aa,
                    0xe258: 0x79ae,
                    0xe259: 0x79b3,
                    0xe25a: 0x79b9,
                    0xe25b: 0x79ba,
                    0xe25c: 0x79c9,
                    0xe25d: 0x79d5,
                    0xe25e: 0x79e7,
                    0xe25f: 0x79ec,
                    0xe260: 0x79e1,
                    0xe261: 0x79e3,
                    0xe262: 0x7a08,
                    0xe263: 0x7a0d,
                    0xe264: 0x7a18,
                    0xe265: 0x7a19,
                    0xe266: 0x7a20,
                    0xe267: 0x7a1f,
                    0xe268: 0x7980,
                    0xe269: 0x7a31,
                    0xe26a: 0x7a3b,
                    0xe26b: 0x7a3e,
                    0xe26c: 0x7a37,
                    0xe26d: 0x7a43,
                    0xe26e: 0x7a57,
                    0xe26f: 0x7a49,
                    0xe270: 0x7a61,
                    0xe271: 0x7a62,
                    0xe272: 0x7a69,
                    0xe273: 0x9f9d,
                    0xe274: 0x7a70,
                    0xe275: 0x7a79,
                    0xe276: 0x7a7d,
                    0xe277: 0x7a88,
                    0xe278: 0x7a97,
                    0xe279: 0x7a95,
                    0xe27a: 0x7a98,
                    0xe27b: 0x7a96,
                    0xe27c: 0x7aa9,
                    0xe27d: 0x7ac8,
                    0xe27e: 0x7ab0,
                    0xe280: 0x7ab6,
                    0xe281: 0x7ac5,
                    0xe282: 0x7ac4,
                    0xe283: 0x7abf,
                    0xe284: 0x9083,
                    0xe285: 0x7ac7,
                    0xe286: 0x7aca,
                    0xe287: 0x7acd,
                    0xe288: 0x7acf,
                    0xe289: 0x7ad5,
                    0xe28a: 0x7ad3,
                    0xe28b: 0x7ad9,
                    0xe28c: 0x7ada,
                    0xe28d: 0x7add,
                    0xe28e: 0x7ae1,
                    0xe28f: 0x7ae2,
                    0xe290: 0x7ae6,
                    0xe291: 0x7aed,
                    0xe292: 0x7af0,
                    0xe293: 0x7b02,
                    0xe294: 0x7b0f,
                    0xe295: 0x7b0a,
                    0xe296: 0x7b06,
                    0xe297: 0x7b33,
                    0xe298: 0x7b18,
                    0xe299: 0x7b19,
                    0xe29a: 0x7b1e,
                    0xe29b: 0x7b35,
                    0xe29c: 0x7b28,
                    0xe29d: 0x7b36,
                    0xe29e: 0x7b50,
                    0xe29f: 0x7b7a,
                    0xe2a0: 0x7b04,
                    0xe2a1: 0x7b4d,
                    0xe2a2: 0x7b0b,
                    0xe2a3: 0x7b4c,
                    0xe2a4: 0x7b45,
                    0xe2a5: 0x7b75,
                    0xe2a6: 0x7b65,
                    0xe2a7: 0x7b74,
                    0xe2a8: 0x7b67,
                    0xe2a9: 0x7b70,
                    0xe2aa: 0x7b71,
                    0xe2ab: 0x7b6c,
                    0xe2ac: 0x7b6e,
                    0xe2ad: 0x7b9d,
                    0xe2ae: 0x7b98,
                    0xe2af: 0x7b9f,
                    0xe2b0: 0x7b8d,
                    0xe2b1: 0x7b9c,
                    0xe2b2: 0x7b9a,
                    0xe2b3: 0x7b8b,
                    0xe2b4: 0x7b92,
                    0xe2b5: 0x7b8f,
                    0xe2b6: 0x7b5d,
                    0xe2b7: 0x7b99,
                    0xe2b8: 0x7bcb,
                    0xe2b9: 0x7bc1,
                    0xe2ba: 0x7bcc,
                    0xe2bb: 0x7bcf,
                    0xe2bc: 0x7bb4,
                    0xe2bd: 0x7bc6,
                    0xe2be: 0x7bdd,
                    0xe2bf: 0x7be9,
                    0xe2c0: 0x7c11,
                    0xe2c1: 0x7c14,
                    0xe2c2: 0x7be6,
                    0xe2c3: 0x7be5,
                    0xe2c4: 0x7c60,
                    0xe2c5: 0x7c00,
                    0xe2c6: 0x7c07,
                    0xe2c7: 0x7c13,
                    0xe2c8: 0x7bf3,
                    0xe2c9: 0x7bf7,
                    0xe2ca: 0x7c17,
                    0xe2cb: 0x7c0d,
                    0xe2cc: 0x7bf6,
                    0xe2cd: 0x7c23,
                    0xe2ce: 0x7c27,
                    0xe2cf: 0x7c2a,
                    0xe2d0: 0x7c1f,
                    0xe2d1: 0x7c37,
                    0xe2d2: 0x7c2b,
                    0xe2d3: 0x7c3d,
                    0xe2d4: 0x7c4c,
                    0xe2d5: 0x7c43,
                    0xe2d6: 0x7c54,
                    0xe2d7: 0x7c4f,
                    0xe2d8: 0x7c40,
                    0xe2d9: 0x7c50,
                    0xe2da: 0x7c58,
                    0xe2db: 0x7c5f,
                    0xe2dc: 0x7c64,
                    0xe2dd: 0x7c56,
                    0xe2de: 0x7c65,
                    0xe2df: 0x7c6c,
                    0xe2e0: 0x7c75,
                    0xe2e1: 0x7c83,
                    0xe2e2: 0x7c90,
                    0xe2e3: 0x7ca4,
                    0xe2e4: 0x7cad,
                    0xe2e5: 0x7ca2,
                    0xe2e6: 0x7cab,
                    0xe2e7: 0x7ca1,
                    0xe2e8: 0x7ca8,
                    0xe2e9: 0x7cb3,
                    0xe2ea: 0x7cb2,
                    0xe2eb: 0x7cb1,
                    0xe2ec: 0x7cae,
                    0xe2ed: 0x7cb9,
                    0xe2ee: 0x7cbd,
                    0xe2ef: 0x7cc0,
                    0xe2f0: 0x7cc5,
                    0xe2f1: 0x7cc2,
                    0xe2f2: 0x7cd8,
                    0xe2f3: 0x7cd2,
                    0xe2f4: 0x7cdc,
                    0xe2f5: 0x7ce2,
                    0xe2f6: 0x9b3b,
                    0xe2f7: 0x7cef,
                    0xe2f8: 0x7cf2,
                    0xe2f9: 0x7cf4,
                    0xe2fa: 0x7cf6,
                    0xe2fb: 0x7cfa,
                    0xe2fc: 0x7d06,
                    0xe340: 0x7d02,
                    0xe341: 0x7d1c,
                    0xe342: 0x7d15,
                    0xe343: 0x7d0a,
                    0xe344: 0x7d45,
                    0xe345: 0x7d4b,
                    0xe346: 0x7d2e,
                    0xe347: 0x7d32,
                    0xe348: 0x7d3f,
                    0xe349: 0x7d35,
                    0xe34a: 0x7d46,
                    0xe34b: 0x7d73,
                    0xe34c: 0x7d56,
                    0xe34d: 0x7d4e,
                    0xe34e: 0x7d72,
                    0xe34f: 0x7d68,
                    0xe350: 0x7d6e,
                    0xe351: 0x7d4f,
                    0xe352: 0x7d63,
                    0xe353: 0x7d93,
                    0xe354: 0x7d89,
                    0xe355: 0x7d5b,
                    0xe356: 0x7d8f,
                    0xe357: 0x7d7d,
                    0xe358: 0x7d9b,
                    0xe359: 0x7dba,
                    0xe35a: 0x7dae,
                    0xe35b: 0x7da3,
                    0xe35c: 0x7db5,
                    0xe35d: 0x7dc7,
                    0xe35e: 0x7dbd,
                    0xe35f: 0x7dab,
                    0xe360: 0x7e3d,
                    0xe361: 0x7da2,
                    0xe362: 0x7daf,
                    0xe363: 0x7ddc,
                    0xe364: 0x7db8,
                    0xe365: 0x7d9f,
                    0xe366: 0x7db0,
                    0xe367: 0x7dd8,
                    0xe368: 0x7ddd,
                    0xe369: 0x7de4,
                    0xe36a: 0x7dde,
                    0xe36b: 0x7dfb,
                    0xe36c: 0x7df2,
                    0xe36d: 0x7de1,
                    0xe36e: 0x7e05,
                    0xe36f: 0x7e0a,
                    0xe370: 0x7e23,
                    0xe371: 0x7e21,
                    0xe372: 0x7e12,
                    0xe373: 0x7e31,
                    0xe374: 0x7e1f,
                    0xe375: 0x7e09,
                    0xe376: 0x7e0b,
                    0xe377: 0x7e22,
                    0xe378: 0x7e46,
                    0xe379: 0x7e66,
                    0xe37a: 0x7e3b,
                    0xe37b: 0x7e35,
                    0xe37c: 0x7e39,
                    0xe37d: 0x7e43,
                    0xe37e: 0x7e37,
                    0xe380: 0x7e32,
                    0xe381: 0x7e3a,
                    0xe382: 0x7e67,
                    0xe383: 0x7e5d,
                    0xe384: 0x7e56,
                    0xe385: 0x7e5e,
                    0xe386: 0x7e59,
                    0xe387: 0x7e5a,
                    0xe388: 0x7e79,
                    0xe389: 0x7e6a,
                    0xe38a: 0x7e69,
                    0xe38b: 0x7e7c,
                    0xe38c: 0x7e7b,
                    0xe38d: 0x7e83,
                    0xe38e: 0x7dd5,
                    0xe38f: 0x7e7d,
                    0xe390: 0x8fae,
                    0xe391: 0x7e7f,
                    0xe392: 0x7e88,
                    0xe393: 0x7e89,
                    0xe394: 0x7e8c,
                    0xe395: 0x7e92,
                    0xe396: 0x7e90,
                    0xe397: 0x7e93,
                    0xe398: 0x7e94,
                    0xe399: 0x7e96,
                    0xe39a: 0x7e8e,
                    0xe39b: 0x7e9b,
                    0xe39c: 0x7e9c,
                    0xe39d: 0x7f38,
                    0xe39e: 0x7f3a,
                    0xe39f: 0x7f45,
                    0xe3a0: 0x7f4c,
                    0xe3a1: 0x7f4d,
                    0xe3a2: 0x7f4e,
                    0xe3a3: 0x7f50,
                    0xe3a4: 0x7f51,
                    0xe3a5: 0x7f55,
                    0xe3a6: 0x7f54,
                    0xe3a7: 0x7f58,
                    0xe3a8: 0x7f5f,
                    0xe3a9: 0x7f60,
                    0xe3aa: 0x7f68,
                    0xe3ab: 0x7f69,
                    0xe3ac: 0x7f67,
                    0xe3ad: 0x7f78,
                    0xe3ae: 0x7f82,
                    0xe3af: 0x7f86,
                    0xe3b0: 0x7f83,
                    0xe3b1: 0x7f88,
                    0xe3b2: 0x7f87,
                    0xe3b3: 0x7f8c,
                    0xe3b4: 0x7f94,
                    0xe3b5: 0x7f9e,
                    0xe3b6: 0x7f9d,
                    0xe3b7: 0x7f9a,
                    0xe3b8: 0x7fa3,
                    0xe3b9: 0x7faf,
                    0xe3ba: 0x7fb2,
                    0xe3bb: 0x7fb9,
                    0xe3bc: 0x7fae,
                    0xe3bd: 0x7fb6,
                    0xe3be: 0x7fb8,
                    0xe3bf: 0x8b71,
                    0xe3c0: 0x7fc5,
                    0xe3c1: 0x7fc6,
                    0xe3c2: 0x7fca,
                    0xe3c3: 0x7fd5,
                    0xe3c4: 0x7fd4,
                    0xe3c5: 0x7fe1,
                    0xe3c6: 0x7fe6,
                    0xe3c7: 0x7fe9,
                    0xe3c8: 0x7ff3,
                    0xe3c9: 0x7ff9,
                    0xe3ca: 0x98dc,
                    0xe3cb: 0x8006,
                    0xe3cc: 0x8004,
                    0xe3cd: 0x800b,
                    0xe3ce: 0x8012,
                    0xe3cf: 0x8018,
                    0xe3d0: 0x8019,
                    0xe3d1: 0x801c,
                    0xe3d2: 0x8021,
                    0xe3d3: 0x8028,
                    0xe3d4: 0x803f,
                    0xe3d5: 0x803b,
                    0xe3d6: 0x804a,
                    0xe3d7: 0x8046,
                    0xe3d8: 0x8052,
                    0xe3d9: 0x8058,
                    0xe3da: 0x805a,
                    0xe3db: 0x805f,
                    0xe3dc: 0x8062,
                    0xe3dd: 0x8068,
                    0xe3de: 0x8073,
                    0xe3df: 0x8072,
                    0xe3e0: 0x8070,
                    0xe3e1: 0x8076,
                    0xe3e2: 0x8079,
                    0xe3e3: 0x807d,
                    0xe3e4: 0x807f,
                    0xe3e5: 0x8084,
                    0xe3e6: 0x8086,
                    0xe3e7: 0x8085,
                    0xe3e8: 0x809b,
                    0xe3e9: 0x8093,
                    0xe3ea: 0x809a,
                    0xe3eb: 0x80ad,
                    0xe3ec: 0x5190,
                    0xe3ed: 0x80ac,
                    0xe3ee: 0x80db,
                    0xe3ef: 0x80e5,
                    0xe3f0: 0x80d9,
                    0xe3f1: 0x80dd,
                    0xe3f2: 0x80c4,
                    0xe3f3: 0x80da,
                    0xe3f4: 0x80d6,
                    0xe3f5: 0x8109,
                    0xe3f6: 0x80ef,
                    0xe3f7: 0x80f1,
                    0xe3f8: 0x811b,
                    0xe3f9: 0x8129,
                    0xe3fa: 0x8123,
                    0xe3fb: 0x812f,
                    0xe3fc: 0x814b,
                    0xe440: 0x968b,
                    0xe441: 0x8146,
                    0xe442: 0x813e,
                    0xe443: 0x8153,
                    0xe444: 0x8151,
                    0xe445: 0x80fc,
                    0xe446: 0x8171,
                    0xe447: 0x816e,
                    0xe448: 0x8165,
                    0xe449: 0x8166,
                    0xe44a: 0x8174,
                    0xe44b: 0x8183,
                    0xe44c: 0x8188,
                    0xe44d: 0x818a,
                    0xe44e: 0x8180,
                    0xe44f: 0x8182,
                    0xe450: 0x81a0,
                    0xe451: 0x8195,
                    0xe452: 0x81a4,
                    0xe453: 0x81a3,
                    0xe454: 0x815f,
                    0xe455: 0x8193,
                    0xe456: 0x81a9,
                    0xe457: 0x81b0,
                    0xe458: 0x81b5,
                    0xe459: 0x81be,
                    0xe45a: 0x81b8,
                    0xe45b: 0x81bd,
                    0xe45c: 0x81c0,
                    0xe45d: 0x81c2,
                    0xe45e: 0x81ba,
                    0xe45f: 0x81c9,
                    0xe460: 0x81cd,
                    0xe461: 0x81d1,
                    0xe462: 0x81d9,
                    0xe463: 0x81d8,
                    0xe464: 0x81c8,
                    0xe465: 0x81da,
                    0xe466: 0x81df,
                    0xe467: 0x81e0,
                    0xe468: 0x81e7,
                    0xe469: 0x81fa,
                    0xe46a: 0x81fb,
                    0xe46b: 0x81fe,
                    0xe46c: 0x8201,
                    0xe46d: 0x8202,
                    0xe46e: 0x8205,
                    0xe46f: 0x8207,
                    0xe470: 0x820a,
                    0xe471: 0x820d,
                    0xe472: 0x8210,
                    0xe473: 0x8216,
                    0xe474: 0x8229,
                    0xe475: 0x822b,
                    0xe476: 0x8238,
                    0xe477: 0x8233,
                    0xe478: 0x8240,
                    0xe479: 0x8259,
                    0xe47a: 0x8258,
                    0xe47b: 0x825d,
                    0xe47c: 0x825a,
                    0xe47d: 0x825f,
                    0xe47e: 0x8264,
                    0xe480: 0x8262,
                    0xe481: 0x8268,
                    0xe482: 0x826a,
                    0xe483: 0x826b,
                    0xe484: 0x822e,
                    0xe485: 0x8271,
                    0xe486: 0x8277,
                    0xe487: 0x8278,
                    0xe488: 0x827e,
                    0xe489: 0x828d,
                    0xe48a: 0x8292,
                    0xe48b: 0x82ab,
                    0xe48c: 0x829f,
                    0xe48d: 0x82bb,
                    0xe48e: 0x82ac,
                    0xe48f: 0x82e1,
                    0xe490: 0x82e3,
                    0xe491: 0x82df,
                    0xe492: 0x82d2,
                    0xe493: 0x82f4,
                    0xe494: 0x82f3,
                    0xe495: 0x82fa,
                    0xe496: 0x8393,
                    0xe497: 0x8303,
                    0xe498: 0x82fb,
                    0xe499: 0x82f9,
                    0xe49a: 0x82de,
                    0xe49b: 0x8306,
                    0xe49c: 0x82dc,
                    0xe49d: 0x8309,
                    0xe49e: 0x82d9,
                    0xe49f: 0x8335,
                    0xe4a0: 0x8334,
                    0xe4a1: 0x8316,
                    0xe4a2: 0x8332,
                    0xe4a3: 0x8331,
                    0xe4a4: 0x8340,
                    0xe4a5: 0x8339,
                    0xe4a6: 0x8350,
                    0xe4a7: 0x8345,
                    0xe4a8: 0x832f,
                    0xe4a9: 0x832b,
                    0xe4aa: 0x8317,
                    0xe4ab: 0x8318,
                    0xe4ac: 0x8385,
                    0xe4ad: 0x839a,
                    0xe4ae: 0x83aa,
                    0xe4af: 0x839f,
                    0xe4b0: 0x83a2,
                    0xe4b1: 0x8396,
                    0xe4b2: 0x8323,
                    0xe4b3: 0x838e,
                    0xe4b4: 0x8387,
                    0xe4b5: 0x838a,
                    0xe4b6: 0x837c,
                    0xe4b7: 0x83b5,
                    0xe4b8: 0x8373,
                    0xe4b9: 0x8375,
                    0xe4ba: 0x83a0,
                    0xe4bb: 0x8389,
                    0xe4bc: 0x83a8,
                    0xe4bd: 0x83f4,
                    0xe4be: 0x8413,
                    0xe4bf: 0x83eb,
                    0xe4c0: 0x83ce,
                    0xe4c1: 0x83fd,
                    0xe4c2: 0x8403,
                    0xe4c3: 0x83d8,
                    0xe4c4: 0x840b,
                    0xe4c5: 0x83c1,
                    0xe4c6: 0x83f7,
                    0xe4c7: 0x8407,
                    0xe4c8: 0x83e0,
                    0xe4c9: 0x83f2,
                    0xe4ca: 0x840d,
                    0xe4cb: 0x8422,
                    0xe4cc: 0x8420,
                    0xe4cd: 0x83bd,
                    0xe4ce: 0x8438,
                    0xe4cf: 0x8506,
                    0xe4d0: 0x83fb,
                    0xe4d1: 0x846d,
                    0xe4d2: 0x842a,
                    0xe4d3: 0x843c,
                    0xe4d4: 0x855a,
                    0xe4d5: 0x8484,
                    0xe4d6: 0x8477,
                    0xe4d7: 0x846b,
                    0xe4d8: 0x84ad,
                    0xe4d9: 0x846e,
                    0xe4da: 0x8482,
                    0xe4db: 0x8469,
                    0xe4dc: 0x8446,
                    0xe4dd: 0x842c,
                    0xe4de: 0x846f,
                    0xe4df: 0x8479,
                    0xe4e0: 0x8435,
                    0xe4e1: 0x84ca,
                    0xe4e2: 0x8462,
                    0xe4e3: 0x84b9,
                    0xe4e4: 0x84bf,
                    0xe4e5: 0x849f,
                    0xe4e6: 0x84d9,
                    0xe4e7: 0x84cd,
                    0xe4e8: 0x84bb,
                    0xe4e9: 0x84da,
                    0xe4ea: 0x84d0,
                    0xe4eb: 0x84c1,
                    0xe4ec: 0x84c6,
                    0xe4ed: 0x84d6,
                    0xe4ee: 0x84a1,
                    0xe4ef: 0x8521,
                    0xe4f0: 0x84ff,
                    0xe4f1: 0x84f4,
                    0xe4f2: 0x8517,
                    0xe4f3: 0x8518,
                    0xe4f4: 0x852c,
                    0xe4f5: 0x851f,
                    0xe4f6: 0x8515,
                    0xe4f7: 0x8514,
                    0xe4f8: 0x84fc,
                    0xe4f9: 0x8540,
                    0xe4fa: 0x8563,
                    0xe4fb: 0x8558,
                    0xe4fc: 0x8548,
                    0xe540: 0x8541,
                    0xe541: 0x8602,
                    0xe542: 0x854b,
                    0xe543: 0x8555,
                    0xe544: 0x8580,
                    0xe545: 0x85a4,
                    0xe546: 0x8588,
                    0xe547: 0x8591,
                    0xe548: 0x858a,
                    0xe549: 0x85a8,
                    0xe54a: 0x856d,
                    0xe54b: 0x8594,
                    0xe54c: 0x859b,
                    0xe54d: 0x85ea,
                    0xe54e: 0x8587,
                    0xe54f: 0x859c,
                    0xe550: 0x8577,
                    0xe551: 0x857e,
                    0xe552: 0x8590,
                    0xe553: 0x85c9,
                    0xe554: 0x85ba,
                    0xe555: 0x85cf,
                    0xe556: 0x85b9,
                    0xe557: 0x85d0,
                    0xe558: 0x85d5,
                    0xe559: 0x85dd,
                    0xe55a: 0x85e5,
                    0xe55b: 0x85dc,
                    0xe55c: 0x85f9,
                    0xe55d: 0x860a,
                    0xe55e: 0x8613,
                    0xe55f: 0x860b,
                    0xe560: 0x85fe,
                    0xe561: 0x85fa,
                    0xe562: 0x8606,
                    0xe563: 0x8622,
                    0xe564: 0x861a,
                    0xe565: 0x8630,
                    0xe566: 0x863f,
                    0xe567: 0x864d,
                    0xe568: 0x4e55,
                    0xe569: 0x8654,
                    0xe56a: 0x865f,
                    0xe56b: 0x8667,
                    0xe56c: 0x8671,
                    0xe56d: 0x8693,
                    0xe56e: 0x86a3,
                    0xe56f: 0x86a9,
                    0xe570: 0x86aa,
                    0xe571: 0x868b,
                    0xe572: 0x868c,
                    0xe573: 0x86b6,
                    0xe574: 0x86af,
                    0xe575: 0x86c4,
                    0xe576: 0x86c6,
                    0xe577: 0x86b0,
                    0xe578: 0x86c9,
                    0xe579: 0x8823,
                    0xe57a: 0x86ab,
                    0xe57b: 0x86d4,
                    0xe57c: 0x86de,
                    0xe57d: 0x86e9,
                    0xe57e: 0x86ec,
                    0xe580: 0x86df,
                    0xe581: 0x86db,
                    0xe582: 0x86ef,
                    0xe583: 0x8712,
                    0xe584: 0x8706,
                    0xe585: 0x8708,
                    0xe586: 0x8700,
                    0xe587: 0x8703,
                    0xe588: 0x86fb,
                    0xe589: 0x8711,
                    0xe58a: 0x8709,
                    0xe58b: 0x870d,
                    0xe58c: 0x86f9,
                    0xe58d: 0x870a,
                    0xe58e: 0x8734,
                    0xe58f: 0x873f,
                    0xe590: 0x8737,
                    0xe591: 0x873b,
                    0xe592: 0x8725,
                    0xe593: 0x8729,
                    0xe594: 0x871a,
                    0xe595: 0x8760,
                    0xe596: 0x875f,
                    0xe597: 0x8778,
                    0xe598: 0x874c,
                    0xe599: 0x874e,
                    0xe59a: 0x8774,
                    0xe59b: 0x8757,
                    0xe59c: 0x8768,
                    0xe59d: 0x876e,
                    0xe59e: 0x8759,
                    0xe59f: 0x8753,
                    0xe5a0: 0x8763,
                    0xe5a1: 0x876a,
                    0xe5a2: 0x8805,
                    0xe5a3: 0x87a2,
                    0xe5a4: 0x879f,
                    0xe5a5: 0x8782,
                    0xe5a6: 0x87af,
                    0xe5a7: 0x87cb,
                    0xe5a8: 0x87bd,
                    0xe5a9: 0x87c0,
                    0xe5aa: 0x87d0,
                    0xe5ab: 0x96d6,
                    0xe5ac: 0x87ab,
                    0xe5ad: 0x87c4,
                    0xe5ae: 0x87b3,
                    0xe5af: 0x87c7,
                    0xe5b0: 0x87c6,
                    0xe5b1: 0x87bb,
                    0xe5b2: 0x87ef,
                    0xe5b3: 0x87f2,
                    0xe5b4: 0x87e0,
                    0xe5b5: 0x880f,
                    0xe5b6: 0x880d,
                    0xe5b7: 0x87fe,
                    0xe5b8: 0x87f6,
                    0xe5b9: 0x87f7,
                    0xe5ba: 0x880e,
                    0xe5bb: 0x87d2,
                    0xe5bc: 0x8811,
                    0xe5bd: 0x8816,
                    0xe5be: 0x8815,
                    0xe5bf: 0x8822,
                    0xe5c0: 0x8821,
                    0xe5c1: 0x8831,
                    0xe5c2: 0x8836,
                    0xe5c3: 0x8839,
                    0xe5c4: 0x8827,
                    0xe5c5: 0x883b,
                    0xe5c6: 0x8844,
                    0xe5c7: 0x8842,
                    0xe5c8: 0x8852,
                    0xe5c9: 0x8859,
                    0xe5ca: 0x885e,
                    0xe5cb: 0x8862,
                    0xe5cc: 0x886b,
                    0xe5cd: 0x8881,
                    0xe5ce: 0x887e,
                    0xe5cf: 0x889e,
                    0xe5d0: 0x8875,
                    0xe5d1: 0x887d,
                    0xe5d2: 0x88b5,
                    0xe5d3: 0x8872,
                    0xe5d4: 0x8882,
                    0xe5d5: 0x8897,
                    0xe5d6: 0x8892,
                    0xe5d7: 0x88ae,
                    0xe5d8: 0x8899,
                    0xe5d9: 0x88a2,
                    0xe5da: 0x888d,
                    0xe5db: 0x88a4,
                    0xe5dc: 0x88b0,
                    0xe5dd: 0x88bf,
                    0xe5de: 0x88b1,
                    0xe5df: 0x88c3,
                    0xe5e0: 0x88c4,
                    0xe5e1: 0x88d4,
                    0xe5e2: 0x88d8,
                    0xe5e3: 0x88d9,
                    0xe5e4: 0x88dd,
                    0xe5e5: 0x88f9,
                    0xe5e6: 0x8902,
                    0xe5e7: 0x88fc,
                    0xe5e8: 0x88f4,
                    0xe5e9: 0x88e8,
                    0xe5ea: 0x88f2,
                    0xe5eb: 0x8904,
                    0xe5ec: 0x890c,
                    0xe5ed: 0x890a,
                    0xe5ee: 0x8913,
                    0xe5ef: 0x8943,
                    0xe5f0: 0x891e,
                    0xe5f1: 0x8925,
                    0xe5f2: 0x892a,
                    0xe5f3: 0x892b,
                    0xe5f4: 0x8941,
                    0xe5f5: 0x8944,
                    0xe5f6: 0x893b,
                    0xe5f7: 0x8936,
                    0xe5f8: 0x8938,
                    0xe5f9: 0x894c,
                    0xe5fa: 0x891d,
                    0xe5fb: 0x8960,
                    0xe5fc: 0x895e,
                    0xe640: 0x8966,
                    0xe641: 0x8964,
                    0xe642: 0x896d,
                    0xe643: 0x896a,
                    0xe644: 0x896f,
                    0xe645: 0x8974,
                    0xe646: 0x8977,
                    0xe647: 0x897e,
                    0xe648: 0x8983,
                    0xe649: 0x8988,
                    0xe64a: 0x898a,
                    0xe64b: 0x8993,
                    0xe64c: 0x8998,
                    0xe64d: 0x89a1,
                    0xe64e: 0x89a9,
                    0xe64f: 0x89a6,
                    0xe650: 0x89ac,
                    0xe651: 0x89af,
                    0xe652: 0x89b2,
                    0xe653: 0x89ba,
                    0xe654: 0x89bd,
                    0xe655: 0x89bf,
                    0xe656: 0x89c0,
                    0xe657: 0x89da,
                    0xe658: 0x89dc,
                    0xe659: 0x89dd,
                    0xe65a: 0x89e7,
                    0xe65b: 0x89f4,
                    0xe65c: 0x89f8,
                    0xe65d: 0x8a03,
                    0xe65e: 0x8a16,
                    0xe65f: 0x8a10,
                    0xe660: 0x8a0c,
                    0xe661: 0x8a1b,
                    0xe662: 0x8a1d,
                    0xe663: 0x8a25,
                    0xe664: 0x8a36,
                    0xe665: 0x8a41,
                    0xe666: 0x8a5b,
                    0xe667: 0x8a52,
                    0xe668: 0x8a46,
                    0xe669: 0x8a48,
                    0xe66a: 0x8a7c,
                    0xe66b: 0x8a6d,
                    0xe66c: 0x8a6c,
                    0xe66d: 0x8a62,
                    0xe66e: 0x8a85,
                    0xe66f: 0x8a82,
                    0xe670: 0x8a84,
                    0xe671: 0x8aa8,
                    0xe672: 0x8aa1,
                    0xe673: 0x8a91,
                    0xe674: 0x8aa5,
                    0xe675: 0x8aa6,
                    0xe676: 0x8a9a,
                    0xe677: 0x8aa3,
                    0xe678: 0x8ac4,
                    0xe679: 0x8acd,
                    0xe67a: 0x8ac2,
                    0xe67b: 0x8ada,
                    0xe67c: 0x8aeb,
                    0xe67d: 0x8af3,
                    0xe67e: 0x8ae7,
                    0xe680: 0x8ae4,
                    0xe681: 0x8af1,
                    0xe682: 0x8b14,
                    0xe683: 0x8ae0,
                    0xe684: 0x8ae2,
                    0xe685: 0x8af7,
                    0xe686: 0x8ade,
                    0xe687: 0x8adb,
                    0xe688: 0x8b0c,
                    0xe689: 0x8b07,
                    0xe68a: 0x8b1a,
                    0xe68b: 0x8ae1,
                    0xe68c: 0x8b16,
                    0xe68d: 0x8b10,
                    0xe68e: 0x8b17,
                    0xe68f: 0x8b20,
                    0xe690: 0x8b33,
                    0xe691: 0x97ab,
                    0xe692: 0x8b26,
                    0xe693: 0x8b2b,
                    0xe694: 0x8b3e,
                    0xe695: 0x8b28,
                    0xe696: 0x8b41,
                    0xe697: 0x8b4c,
                    0xe698: 0x8b4f,
                    0xe699: 0x8b4e,
                    0xe69a: 0x8b49,
                    0xe69b: 0x8b56,
                    0xe69c: 0x8b5b,
                    0xe69d: 0x8b5a,
                    0xe69e: 0x8b6b,
                    0xe69f: 0x8b5f,
                    0xe6a0: 0x8b6c,
                    0xe6a1: 0x8b6f,
                    0xe6a2: 0x8b74,
                    0xe6a3: 0x8b7d,
                    0xe6a4: 0x8b80,
                    0xe6a5: 0x8b8c,
                    0xe6a6: 0x8b8e,
                    0xe6a7: 0x8b92,
                    0xe6a8: 0x8b93,
                    0xe6a9: 0x8b96,
                    0xe6aa: 0x8b99,
                    0xe6ab: 0x8b9a,
                    0xe6ac: 0x8c3a,
                    0xe6ad: 0x8c41,
                    0xe6ae: 0x8c3f,
                    0xe6af: 0x8c48,
                    0xe6b0: 0x8c4c,
                    0xe6b1: 0x8c4e,
                    0xe6b2: 0x8c50,
                    0xe6b3: 0x8c55,
                    0xe6b4: 0x8c62,
                    0xe6b5: 0x8c6c,
                    0xe6b6: 0x8c78,
                    0xe6b7: 0x8c7a,
                    0xe6b8: 0x8c82,
                    0xe6b9: 0x8c89,
                    0xe6ba: 0x8c85,
                    0xe6bb: 0x8c8a,
                    0xe6bc: 0x8c8d,
                    0xe6bd: 0x8c8e,
                    0xe6be: 0x8c94,
                    0xe6bf: 0x8c7c,
                    0xe6c0: 0x8c98,
                    0xe6c1: 0x621d,
                    0xe6c2: 0x8cad,
                    0xe6c3: 0x8caa,
                    0xe6c4: 0x8cbd,
                    0xe6c5: 0x8cb2,
                    0xe6c6: 0x8cb3,
                    0xe6c7: 0x8cae,
                    0xe6c8: 0x8cb6,
                    0xe6c9: 0x8cc8,
                    0xe6ca: 0x8cc1,
                    0xe6cb: 0x8ce4,
                    0xe6cc: 0x8ce3,
                    0xe6cd: 0x8cda,
                    0xe6ce: 0x8cfd,
                    0xe6cf: 0x8cfa,
                    0xe6d0: 0x8cfb,
                    0xe6d1: 0x8d04,
                    0xe6d2: 0x8d05,
                    0xe6d3: 0x8d0a,
                    0xe6d4: 0x8d07,
                    0xe6d5: 0x8d0f,
                    0xe6d6: 0x8d0d,
                    0xe6d7: 0x8d10,
                    0xe6d8: 0x9f4e,
                    0xe6d9: 0x8d13,
                    0xe6da: 0x8ccd,
                    0xe6db: 0x8d14,
                    0xe6dc: 0x8d16,
                    0xe6dd: 0x8d67,
                    0xe6de: 0x8d6d,
                    0xe6df: 0x8d71,
                    0xe6e0: 0x8d73,
                    0xe6e1: 0x8d81,
                    0xe6e2: 0x8d99,
                    0xe6e3: 0x8dc2,
                    0xe6e4: 0x8dbe,
                    0xe6e5: 0x8dba,
                    0xe6e6: 0x8dcf,
                    0xe6e7: 0x8dda,
                    0xe6e8: 0x8dd6,
                    0xe6e9: 0x8dcc,
                    0xe6ea: 0x8ddb,
                    0xe6eb: 0x8dcb,
                    0xe6ec: 0x8dea,
                    0xe6ed: 0x8deb,
                    0xe6ee: 0x8ddf,
                    0xe6ef: 0x8de3,
                    0xe6f0: 0x8dfc,
                    0xe6f1: 0x8e08,
                    0xe6f2: 0x8e09,
                    0xe6f3: 0x8dff,
                    0xe6f4: 0x8e1d,
                    0xe6f5: 0x8e1e,
                    0xe6f6: 0x8e10,
                    0xe6f7: 0x8e1f,
                    0xe6f8: 0x8e42,
                    0xe6f9: 0x8e35,
                    0xe6fa: 0x8e30,
                    0xe6fb: 0x8e34,
                    0xe6fc: 0x8e4a,
                    0xe740: 0x8e47,
                    0xe741: 0x8e49,
                    0xe742: 0x8e4c,
                    0xe743: 0x8e50,
                    0xe744: 0x8e48,
                    0xe745: 0x8e59,
                    0xe746: 0x8e64,
                    0xe747: 0x8e60,
                    0xe748: 0x8e2a,
                    0xe749: 0x8e63,
                    0xe74a: 0x8e55,
                    0xe74b: 0x8e76,
                    0xe74c: 0x8e72,
                    0xe74d: 0x8e7c,
                    0xe74e: 0x8e81,
                    0xe74f: 0x8e87,
                    0xe750: 0x8e85,
                    0xe751: 0x8e84,
                    0xe752: 0x8e8b,
                    0xe753: 0x8e8a,
                    0xe754: 0x8e93,
                    0xe755: 0x8e91,
                    0xe756: 0x8e94,
                    0xe757: 0x8e99,
                    0xe758: 0x8eaa,
                    0xe759: 0x8ea1,
                    0xe75a: 0x8eac,
                    0xe75b: 0x8eb0,
                    0xe75c: 0x8ec6,
                    0xe75d: 0x8eb1,
                    0xe75e: 0x8ebe,
                    0xe75f: 0x8ec5,
                    0xe760: 0x8ec8,
                    0xe761: 0x8ecb,
                    0xe762: 0x8edb,
                    0xe763: 0x8ee3,
                    0xe764: 0x8efc,
                    0xe765: 0x8efb,
                    0xe766: 0x8eeb,
                    0xe767: 0x8efe,
                    0xe768: 0x8f0a,
                    0xe769: 0x8f05,
                    0xe76a: 0x8f15,
                    0xe76b: 0x8f12,
                    0xe76c: 0x8f19,
                    0xe76d: 0x8f13,
                    0xe76e: 0x8f1c,
                    0xe76f: 0x8f1f,
                    0xe770: 0x8f1b,
                    0xe771: 0x8f0c,
                    0xe772: 0x8f26,
                    0xe773: 0x8f33,
                    0xe774: 0x8f3b,
                    0xe775: 0x8f39,
                    0xe776: 0x8f45,
                    0xe777: 0x8f42,
                    0xe778: 0x8f3e,
                    0xe779: 0x8f4c,
                    0xe77a: 0x8f49,
                    0xe77b: 0x8f46,
                    0xe77c: 0x8f4e,
                    0xe77d: 0x8f57,
                    0xe77e: 0x8f5c,
                    0xe780: 0x8f62,
                    0xe781: 0x8f63,
                    0xe782: 0x8f64,
                    0xe783: 0x8f9c,
                    0xe784: 0x8f9f,
                    0xe785: 0x8fa3,
                    0xe786: 0x8fad,
                    0xe787: 0x8faf,
                    0xe788: 0x8fb7,
                    0xe789: 0x8fda,
                    0xe78a: 0x8fe5,
                    0xe78b: 0x8fe2,
                    0xe78c: 0x8fea,
                    0xe78d: 0x8fef,
                    0xe78e: 0x9087,
                    0xe78f: 0x8ff4,
                    0xe790: 0x9005,
                    0xe791: 0x8ff9,
                    0xe792: 0x8ffa,
                    0xe793: 0x9011,
                    0xe794: 0x9015,
                    0xe795: 0x9021,
                    0xe796: 0x900d,
                    0xe797: 0x901e,
                    0xe798: 0x9016,
                    0xe799: 0x900b,
                    0xe79a: 0x9027,
                    0xe79b: 0x9036,
                    0xe79c: 0x9035,
                    0xe79d: 0x9039,
                    0xe79e: 0x8ff8,
                    0xe79f: 0x904f,
                    0xe7a0: 0x9050,
                    0xe7a1: 0x9051,
                    0xe7a2: 0x9052,
                    0xe7a3: 0x900e,
                    0xe7a4: 0x9049,
                    0xe7a5: 0x903e,
                    0xe7a6: 0x9056,
                    0xe7a7: 0x9058,
                    0xe7a8: 0x905e,
                    0xe7a9: 0x9068,
                    0xe7aa: 0x906f,
                    0xe7ab: 0x9076,
                    0xe7ac: 0x96a8,
                    0xe7ad: 0x9072,
                    0xe7ae: 0x9082,
                    0xe7af: 0x907d,
                    0xe7b0: 0x9081,
                    0xe7b1: 0x9080,
                    0xe7b2: 0x908a,
                    0xe7b3: 0x9089,
                    0xe7b4: 0x908f,
                    0xe7b5: 0x90a8,
                    0xe7b6: 0x90af,
                    0xe7b7: 0x90b1,
                    0xe7b8: 0x90b5,
                    0xe7b9: 0x90e2,
                    0xe7ba: 0x90e4,
                    0xe7bb: 0x6248,
                    0xe7bc: 0x90db,
                    0xe7bd: 0x9102,
                    0xe7be: 0x9112,
                    0xe7bf: 0x9119,
                    0xe7c0: 0x9132,
                    0xe7c1: 0x9130,
                    0xe7c2: 0x914a,
                    0xe7c3: 0x9156,
                    0xe7c4: 0x9158,
                    0xe7c5: 0x9163,
                    0xe7c6: 0x9165,
                    0xe7c7: 0x9169,
                    0xe7c8: 0x9173,
                    0xe7c9: 0x9172,
                    0xe7ca: 0x918b,
                    0xe7cb: 0x9189,
                    0xe7cc: 0x9182,
                    0xe7cd: 0x91a2,
                    0xe7ce: 0x91ab,
                    0xe7cf: 0x91af,
                    0xe7d0: 0x91aa,
                    0xe7d1: 0x91b5,
                    0xe7d2: 0x91b4,
                    0xe7d3: 0x91ba,
                    0xe7d4: 0x91c0,
                    0xe7d5: 0x91c1,
                    0xe7d6: 0x91c9,
                    0xe7d7: 0x91cb,
                    0xe7d8: 0x91d0,
                    0xe7d9: 0x91d6,
                    0xe7da: 0x91df,
                    0xe7db: 0x91e1,
                    0xe7dc: 0x91db,
                    0xe7dd: 0x91fc,
                    0xe7de: 0x91f5,
                    0xe7df: 0x91f6,
                    0xe7e0: 0x921e,
                    0xe7e1: 0x91ff,
                    0xe7e2: 0x9214,
                    0xe7e3: 0x922c,
                    0xe7e4: 0x9215,
                    0xe7e5: 0x9211,
                    0xe7e6: 0x925e,
                    0xe7e7: 0x9257,
                    0xe7e8: 0x9245,
                    0xe7e9: 0x9249,
                    0xe7ea: 0x9264,
                    0xe7eb: 0x9248,
                    0xe7ec: 0x9295,
                    0xe7ed: 0x923f,
                    0xe7ee: 0x924b,
                    0xe7ef: 0x9250,
                    0xe7f0: 0x929c,
                    0xe7f1: 0x9296,
                    0xe7f2: 0x9293,
                    0xe7f3: 0x929b,
                    0xe7f4: 0x925a,
                    0xe7f5: 0x92cf,
                    0xe7f6: 0x92b9,
                    0xe7f7: 0x92b7,
                    0xe7f8: 0x92e9,
                    0xe7f9: 0x930f,
                    0xe7fa: 0x92fa,
                    0xe7fb: 0x9344,
                    0xe7fc: 0x932e,
                    0xe840: 0x9319,
                    0xe841: 0x9322,
                    0xe842: 0x931a,
                    0xe843: 0x9323,
                    0xe844: 0x933a,
                    0xe845: 0x9335,
                    0xe846: 0x933b,
                    0xe847: 0x935c,
                    0xe848: 0x9360,
                    0xe849: 0x937c,
                    0xe84a: 0x936e,
                    0xe84b: 0x9356,
                    0xe84c: 0x93b0,
                    0xe84d: 0x93ac,
                    0xe84e: 0x93ad,
                    0xe84f: 0x9394,
                    0xe850: 0x93b9,
                    0xe851: 0x93d6,
                    0xe852: 0x93d7,
                    0xe853: 0x93e8,
                    0xe854: 0x93e5,
                    0xe855: 0x93d8,
                    0xe856: 0x93c3,
                    0xe857: 0x93dd,
                    0xe858: 0x93d0,
                    0xe859: 0x93c8,
                    0xe85a: 0x93e4,
                    0xe85b: 0x941a,
                    0xe85c: 0x9414,
                    0xe85d: 0x9413,
                    0xe85e: 0x9403,
                    0xe85f: 0x9407,
                    0xe860: 0x9410,
                    0xe861: 0x9436,
                    0xe862: 0x942b,
                    0xe863: 0x9435,
                    0xe864: 0x9421,
                    0xe865: 0x943a,
                    0xe866: 0x9441,
                    0xe867: 0x9452,
                    0xe868: 0x9444,
                    0xe869: 0x945b,
                    0xe86a: 0x9460,
                    0xe86b: 0x9462,
                    0xe86c: 0x945e,
                    0xe86d: 0x946a,
                    0xe86e: 0x9229,
                    0xe86f: 0x9470,
                    0xe870: 0x9475,
                    0xe871: 0x9477,
                    0xe872: 0x947d,
                    0xe873: 0x945a,
                    0xe874: 0x947c,
                    0xe875: 0x947e,
                    0xe876: 0x9481,
                    0xe877: 0x947f,
                    0xe878: 0x9582,
                    0xe879: 0x9587,
                    0xe87a: 0x958a,
                    0xe87b: 0x9594,
                    0xe87c: 0x9596,
                    0xe87d: 0x9598,
                    0xe87e: 0x9599,
                    0xe880: 0x95a0,
                    0xe881: 0x95a8,
                    0xe882: 0x95a7,
                    0xe883: 0x95ad,
                    0xe884: 0x95bc,
                    0xe885: 0x95bb,
                    0xe886: 0x95b9,
                    0xe887: 0x95be,
                    0xe888: 0x95ca,
                    0xe889: 0x6ff6,
                    0xe88a: 0x95c3,
                    0xe88b: 0x95cd,
                    0xe88c: 0x95cc,
                    0xe88d: 0x95d5,
                    0xe88e: 0x95d4,
                    0xe88f: 0x95d6,
                    0xe890: 0x95dc,
                    0xe891: 0x95e1,
                    0xe892: 0x95e5,
                    0xe893: 0x95e2,
                    0xe894: 0x9621,
                    0xe895: 0x9628,
                    0xe896: 0x962e,
                    0xe897: 0x962f,
                    0xe898: 0x9642,
                    0xe899: 0x964c,
                    0xe89a: 0x964f,
                    0xe89b: 0x964b,
                    0xe89c: 0x9677,
                    0xe89d: 0x965c,
                    0xe89e: 0x965e,
                    0xe89f: 0x965d,
                    0xe8a0: 0x965f,
                    0xe8a1: 0x9666,
                    0xe8a2: 0x9672,
                    0xe8a3: 0x966c,
                    0xe8a4: 0x968d,
                    0xe8a5: 0x9698,
                    0xe8a6: 0x9695,
                    0xe8a7: 0x9697,
                    0xe8a8: 0x96aa,
                    0xe8a9: 0x96a7,
                    0xe8aa: 0x96b1,
                    0xe8ab: 0x96b2,
                    0xe8ac: 0x96b0,
                    0xe8ad: 0x96b4,
                    0xe8ae: 0x96b6,
                    0xe8af: 0x96b8,
                    0xe8b0: 0x96b9,
                    0xe8b1: 0x96ce,
                    0xe8b2: 0x96cb,
                    0xe8b3: 0x96c9,
                    0xe8b4: 0x96cd,
                    0xe8b5: 0x894d,
                    0xe8b6: 0x96dc,
                    0xe8b7: 0x970d,
                    0xe8b8: 0x96d5,
                    0xe8b9: 0x96f9,
                    0xe8ba: 0x9704,
                    0xe8bb: 0x9706,
                    0xe8bc: 0x9708,
                    0xe8bd: 0x9713,
                    0xe8be: 0x970e,
                    0xe8bf: 0x9711,
                    0xe8c0: 0x970f,
                    0xe8c1: 0x9716,
                    0xe8c2: 0x9719,
                    0xe8c3: 0x9724,
                    0xe8c4: 0x972a,
                    0xe8c5: 0x9730,
                    0xe8c6: 0x9739,
                    0xe8c7: 0x973d,
                    0xe8c8: 0x973e,
                    0xe8c9: 0x9744,
                    0xe8ca: 0x9746,
                    0xe8cb: 0x9748,
                    0xe8cc: 0x9742,
                    0xe8cd: 0x9749,
                    0xe8ce: 0x975c,
                    0xe8cf: 0x9760,
                    0xe8d0: 0x9764,
                    0xe8d1: 0x9766,
                    0xe8d2: 0x9768,
                    0xe8d3: 0x52d2,
                    0xe8d4: 0x976b,
                    0xe8d5: 0x9771,
                    0xe8d6: 0x9779,
                    0xe8d7: 0x9785,
                    0xe8d8: 0x977c,
                    0xe8d9: 0x9781,
                    0xe8da: 0x977a,
                    0xe8db: 0x9786,
                    0xe8dc: 0x978b,
                    0xe8dd: 0x978f,
                    0xe8de: 0x9790,
                    0xe8df: 0x979c,
                    0xe8e0: 0x97a8,
                    0xe8e1: 0x97a6,
                    0xe8e2: 0x97a3,
                    0xe8e3: 0x97b3,
                    0xe8e4: 0x97b4,
                    0xe8e5: 0x97c3,
                    0xe8e6: 0x97c6,
                    0xe8e7: 0x97c8,
                    0xe8e8: 0x97cb,
                    0xe8e9: 0x97dc,
                    0xe8ea: 0x97ed,
                    0xe8eb: 0x9f4f,
                    0xe8ec: 0x97f2,
                    0xe8ed: 0x7adf,
                    0xe8ee: 0x97f6,
                    0xe8ef: 0x97f5,
                    0xe8f0: 0x980f,
                    0xe8f1: 0x980c,
                    0xe8f2: 0x9838,
                    0xe8f3: 0x9824,
                    0xe8f4: 0x9821,
                    0xe8f5: 0x9837,
                    0xe8f6: 0x983d,
                    0xe8f7: 0x9846,
                    0xe8f8: 0x984f,
                    0xe8f9: 0x984b,
                    0xe8fa: 0x986b,
                    0xe8fb: 0x986f,
                    0xe8fc: 0x9870,
                    0xe940: 0x9871,
                    0xe941: 0x9874,
                    0xe942: 0x9873,
                    0xe943: 0x98aa,
                    0xe944: 0x98af,
                    0xe945: 0x98b1,
                    0xe946: 0x98b6,
                    0xe947: 0x98c4,
                    0xe948: 0x98c3,
                    0xe949: 0x98c6,
                    0xe94a: 0x98e9,
                    0xe94b: 0x98eb,
                    0xe94c: 0x9903,
                    0xe94d: 0x9909,
                    0xe94e: 0x9912,
                    0xe94f: 0x9914,
                    0xe950: 0x9918,
                    0xe951: 0x9921,
                    0xe952: 0x991d,
                    0xe953: 0x991e,
                    0xe954: 0x9924,
                    0xe955: 0x9920,
                    0xe956: 0x992c,
                    0xe957: 0x992e,
                    0xe958: 0x993d,
                    0xe959: 0x993e,
                    0xe95a: 0x9942,
                    0xe95b: 0x9949,
                    0xe95c: 0x9945,
                    0xe95d: 0x9950,
                    0xe95e: 0x994b,
                    0xe95f: 0x9951,
                    0xe960: 0x9952,
                    0xe961: 0x994c,
                    0xe962: 0x9955,
                    0xe963: 0x9997,
                    0xe964: 0x9998,
                    0xe965: 0x99a5,
                    0xe966: 0x99ad,
                    0xe967: 0x99ae,
                    0xe968: 0x99bc,
                    0xe969: 0x99df,
                    0xe96a: 0x99db,
                    0xe96b: 0x99dd,
                    0xe96c: 0x99d8,
                    0xe96d: 0x99d1,
                    0xe96e: 0x99ed,
                    0xe96f: 0x99ee,
                    0xe970: 0x99f1,
                    0xe971: 0x99f2,
                    0xe972: 0x99fb,
                    0xe973: 0x99f8,
                    0xe974: 0x9a01,
                    0xe975: 0x9a0f,
                    0xe976: 0x9a05,
                    0xe977: 0x99e2,
                    0xe978: 0x9a19,
                    0xe979: 0x9a2b,
                    0xe97a: 0x9a37,
                    0xe97b: 0x9a45,
                    0xe97c: 0x9a42,
                    0xe97d: 0x9a40,
                    0xe97e: 0x9a43,
                    0xe980: 0x9a3e,
                    0xe981: 0x9a55,
                    0xe982: 0x9a4d,
                    0xe983: 0x9a5b,
                    0xe984: 0x9a57,
                    0xe985: 0x9a5f,
                    0xe986: 0x9a62,
                    0xe987: 0x9a65,
                    0xe988: 0x9a64,
                    0xe989: 0x9a69,
                    0xe98a: 0x9a6b,
                    0xe98b: 0x9a6a,
                    0xe98c: 0x9aad,
                    0xe98d: 0x9ab0,
                    0xe98e: 0x9abc,
                    0xe98f: 0x9ac0,
                    0xe990: 0x9acf,
                    0xe991: 0x9ad1,
                    0xe992: 0x9ad3,
                    0xe993: 0x9ad4,
                    0xe994: 0x9ade,
                    0xe995: 0x9adf,
                    0xe996: 0x9ae2,
                    0xe997: 0x9ae3,
                    0xe998: 0x9ae6,
                    0xe999: 0x9aef,
                    0xe99a: 0x9aeb,
                    0xe99b: 0x9aee,
                    0xe99c: 0x9af4,
                    0xe99d: 0x9af1,
                    0xe99e: 0x9af7,
                    0xe99f: 0x9afb,
                    0xe9a0: 0x9b06,
                    0xe9a1: 0x9b18,
                    0xe9a2: 0x9b1a,
                    0xe9a3: 0x9b1f,
                    0xe9a4: 0x9b22,
                    0xe9a5: 0x9b23,
                    0xe9a6: 0x9b25,
                    0xe9a7: 0x9b27,
                    0xe9a8: 0x9b28,
                    0xe9a9: 0x9b29,
                    0xe9aa: 0x9b2a,
                    0xe9ab: 0x9b2e,
                    0xe9ac: 0x9b2f,
                    0xe9ad: 0x9b32,
                    0xe9ae: 0x9b44,
                    0xe9af: 0x9b43,
                    0xe9b0: 0x9b4f,
                    0xe9b1: 0x9b4d,
                    0xe9b2: 0x9b4e,
                    0xe9b3: 0x9b51,
                    0xe9b4: 0x9b58,
                    0xe9b5: 0x9b74,
                    0xe9b6: 0x9b93,
                    0xe9b7: 0x9b83,
                    0xe9b8: 0x9b91,
                    0xe9b9: 0x9b96,
                    0xe9ba: 0x9b97,
                    0xe9bb: 0x9b9f,
                    0xe9bc: 0x9ba0,
                    0xe9bd: 0x9ba8,
                    0xe9be: 0x9bb4,
                    0xe9bf: 0x9bc0,
                    0xe9c0: 0x9bca,
                    0xe9c1: 0x9bb9,
                    0xe9c2: 0x9bc6,
                    0xe9c3: 0x9bcf,
                    0xe9c4: 0x9bd1,
                    0xe9c5: 0x9bd2,
                    0xe9c6: 0x9be3,
                    0xe9c7: 0x9be2,
                    0xe9c8: 0x9be4,
                    0xe9c9: 0x9bd4,
                    0xe9ca: 0x9be1,
                    0xe9cb: 0x9c3a,
                    0xe9cc: 0x9bf2,
                    0xe9cd: 0x9bf1,
                    0xe9ce: 0x9bf0,
                    0xe9cf: 0x9c15,
                    0xe9d0: 0x9c14,
                    0xe9d1: 0x9c09,
                    0xe9d2: 0x9c13,
                    0xe9d3: 0x9c0c,
                    0xe9d4: 0x9c06,
                    0xe9d5: 0x9c08,
                    0xe9d6: 0x9c12,
                    0xe9d7: 0x9c0a,
                    0xe9d8: 0x9c04,
                    0xe9d9: 0x9c2e,
                    0xe9da: 0x9c1b,
                    0xe9db: 0x9c25,
                    0xe9dc: 0x9c24,
                    0xe9dd: 0x9c21,
                    0xe9de: 0x9c30,
                    0xe9df: 0x9c47,
                    0xe9e0: 0x9c32,
                    0xe9e1: 0x9c46,
                    0xe9e2: 0x9c3e,
                    0xe9e3: 0x9c5a,
                    0xe9e4: 0x9c60,
                    0xe9e5: 0x9c67,
                    0xe9e6: 0x9c76,
                    0xe9e7: 0x9c78,
                    0xe9e8: 0x9ce7,
                    0xe9e9: 0x9cec,
                    0xe9ea: 0x9cf0,
                    0xe9eb: 0x9d09,
                    0xe9ec: 0x9d08,
                    0xe9ed: 0x9ceb,
                    0xe9ee: 0x9d03,
                    0xe9ef: 0x9d06,
                    0xe9f0: 0x9d2a,
                    0xe9f1: 0x9d26,
                    0xe9f2: 0x9daf,
                    0xe9f3: 0x9d23,
                    0xe9f4: 0x9d1f,
                    0xe9f5: 0x9d44,
                    0xe9f6: 0x9d15,
                    0xe9f7: 0x9d12,
                    0xe9f8: 0x9d41,
                    0xe9f9: 0x9d3f,
                    0xe9fa: 0x9d3e,
                    0xe9fb: 0x9d46,
                    0xe9fc: 0x9d48,
                    0xea40: 0x9d5d,
                    0xea41: 0x9d5e,
                    0xea42: 0x9d64,
                    0xea43: 0x9d51,
                    0xea44: 0x9d50,
                    0xea45: 0x9d59,
                    0xea46: 0x9d72,
                    0xea47: 0x9d89,
                    0xea48: 0x9d87,
                    0xea49: 0x9dab,
                    0xea4a: 0x9d6f,
                    0xea4b: 0x9d7a,
                    0xea4c: 0x9d9a,
                    0xea4d: 0x9da4,
                    0xea4e: 0x9da9,
                    0xea4f: 0x9db2,
                    0xea50: 0x9dc4,
                    0xea51: 0x9dc1,
                    0xea52: 0x9dbb,
                    0xea53: 0x9db8,
                    0xea54: 0x9dba,
                    0xea55: 0x9dc6,
                    0xea56: 0x9dcf,
                    0xea57: 0x9dc2,
                    0xea58: 0x9dd9,
                    0xea59: 0x9dd3,
                    0xea5a: 0x9df8,
                    0xea5b: 0x9de6,
                    0xea5c: 0x9ded,
                    0xea5d: 0x9def,
                    0xea5e: 0x9dfd,
                    0xea5f: 0x9e1a,
                    0xea60: 0x9e1b,
                    0xea61: 0x9e1e,
                    0xea62: 0x9e75,
                    0xea63: 0x9e79,
                    0xea64: 0x9e7d,
                    0xea65: 0x9e81,
                    0xea66: 0x9e88,
                    0xea67: 0x9e8b,
                    0xea68: 0x9e8c,
                    0xea69: 0x9e92,
                    0xea6a: 0x9e95,
                    0xea6b: 0x9e91,
                    0xea6c: 0x9e9d,
                    0xea6d: 0x9ea5,
                    0xea6e: 0x9ea9,
                    0xea6f: 0x9eb8,
                    0xea70: 0x9eaa,
                    0xea71: 0x9ead,
                    0xea72: 0x9761,
                    0xea73: 0x9ecc,
                    0xea74: 0x9ece,
                    0xea75: 0x9ecf,
                    0xea76: 0x9ed0,
                    0xea77: 0x9ed4,
                    0xea78: 0x9edc,
                    0xea79: 0x9ede,
                    0xea7a: 0x9edd,
                    0xea7b: 0x9ee0,
                    0xea7c: 0x9ee5,
                    0xea7d: 0x9ee8,
                    0xea7e: 0x9eef,
                    0xea80: 0x9ef4,
                    0xea81: 0x9ef6,
                    0xea82: 0x9ef7,
                    0xea83: 0x9ef9,
                    0xea84: 0x9efb,
                    0xea85: 0x9efc,
                    0xea86: 0x9efd,
                    0xea87: 0x9f07,
                    0xea88: 0x9f08,
                    0xea89: 0x76b7,
                    0xea8a: 0x9f15,
                    0xea8b: 0x9f21,
                    0xea8c: 0x9f2c,
                    0xea8d: 0x9f3e,
                    0xea8e: 0x9f4a,
                    0xea8f: 0x9f52,
                    0xea90: 0x9f54,
                    0xea91: 0x9f63,
                    0xea92: 0x9f5f,
                    0xea93: 0x9f60,
                    0xea94: 0x9f61,
                    0xea95: 0x9f66,
                    0xea96: 0x9f67,
                    0xea97: 0x9f6c,
                    0xea98: 0x9f6a,
                    0xea99: 0x9f77,
                    0xea9a: 0x9f72,
                    0xea9b: 0x9f76,
                    0xea9c: 0x9f95,
                    0xea9d: 0x9f9c,
                    0xea9e: 0x9fa0,
                    0xea9f: 0x582f,
                    0xeaa0: 0x69c7,
                    0xeaa1: 0x9059,
                    0xeaa2: 0x7464,
                    0xeaa3: 0x51dc,
                    0xeaa4: 0x7199,
                };

                /***/
            },
            /* 9 */
            /***/ function (module, exports, __webpack_require__) {
                "use strict";

                Object.defineProperty(exports, "__esModule", { value: true });
                var GenericGF_1 = __webpack_require__(1);
                var GenericGFPoly_1 = __webpack_require__(2);
                function runEuclideanAlgorithm(field, a, b, R) {
                    var _a;
                    // Assume a's degree is >= b's
                    if (a.degree() < b.degree()) {
                        (_a = [b, a]), (a = _a[0]), (b = _a[1]);
                    }
                    var rLast = a;
                    var r = b;
                    var tLast = field.zero;
                    var t = field.one;
                    // Run Euclidean algorithm until r's degree is less than R/2
                    while (r.degree() >= R / 2) {
                        var rLastLast = rLast;
                        var tLastLast = tLast;
                        rLast = r;
                        tLast = t;
                        // Divide rLastLast by rLast, with quotient in q and remainder in r
                        if (rLast.isZero()) {
                            // Euclidean algorithm already terminated?
                            return null;
                        }
                        r = rLastLast;
                        var q = field.zero;
                        var denominatorLeadingTerm = rLast.getCoefficient(
                            rLast.degree()
                        );
                        var dltInverse = field.inverse(denominatorLeadingTerm);
                        while (r.degree() >= rLast.degree() && !r.isZero()) {
                            var degreeDiff = r.degree() - rLast.degree();
                            var scale = field.multiply(
                                r.getCoefficient(r.degree()),
                                dltInverse
                            );
                            q = q.addOrSubtract(
                                field.buildMonomial(degreeDiff, scale)
                            );
                            r = r.addOrSubtract(
                                rLast.multiplyByMonomial(degreeDiff, scale)
                            );
                        }
                        t = q.multiplyPoly(tLast).addOrSubtract(tLastLast);
                        if (r.degree() >= rLast.degree()) {
                            return null;
                        }
                    }
                    var sigmaTildeAtZero = t.getCoefficient(0);
                    if (sigmaTildeAtZero === 0) {
                        return null;
                    }
                    var inverse = field.inverse(sigmaTildeAtZero);
                    return [t.multiply(inverse), r.multiply(inverse)];
                }
                function findErrorLocations(field, errorLocator) {
                    // This is a direct application of Chien's search
                    var numErrors = errorLocator.degree();
                    if (numErrors === 1) {
                        return [errorLocator.getCoefficient(1)];
                    }
                    var result = new Array(numErrors);
                    var errorCount = 0;
                    for (
                        var i = 1;
                        i < field.size && errorCount < numErrors;
                        i++
                    ) {
                        if (errorLocator.evaluateAt(i) === 0) {
                            result[errorCount] = field.inverse(i);
                            errorCount++;
                        }
                    }
                    if (errorCount !== numErrors) {
                        return null;
                    }
                    return result;
                }
                function findErrorMagnitudes(
                    field,
                    errorEvaluator,
                    errorLocations
                ) {
                    // This is directly applying Forney's Formula
                    var s = errorLocations.length;
                    var result = new Array(s);
                    for (var i = 0; i < s; i++) {
                        var xiInverse = field.inverse(errorLocations[i]);
                        var denominator = 1;
                        for (var j = 0; j < s; j++) {
                            if (i !== j) {
                                denominator = field.multiply(
                                    denominator,
                                    GenericGF_1.addOrSubtractGF(
                                        1,
                                        field.multiply(
                                            errorLocations[j],
                                            xiInverse
                                        )
                                    )
                                );
                            }
                        }
                        result[i] = field.multiply(
                            errorEvaluator.evaluateAt(xiInverse),
                            field.inverse(denominator)
                        );
                        if (field.generatorBase !== 0) {
                            result[i] = field.multiply(result[i], xiInverse);
                        }
                    }
                    return result;
                }
                function decode(bytes, twoS) {
                    var outputBytes = new Uint8ClampedArray(bytes.length);
                    outputBytes.set(bytes);
                    var field = new GenericGF_1.default(0x011d, 256, 0); // x^8 + x^4 + x^3 + x^2 + 1
                    var poly = new GenericGFPoly_1.default(field, outputBytes);
                    var syndromeCoefficients = new Uint8ClampedArray(twoS);
                    var error = false;
                    for (var s = 0; s < twoS; s++) {
                        var evaluation = poly.evaluateAt(
                            field.exp(s + field.generatorBase)
                        );
                        syndromeCoefficients[
                            syndromeCoefficients.length - 1 - s
                        ] = evaluation;
                        if (evaluation !== 0) {
                            error = true;
                        }
                    }
                    if (!error) {
                        return outputBytes;
                    }
                    var syndrome = new GenericGFPoly_1.default(
                        field,
                        syndromeCoefficients
                    );
                    var sigmaOmega = runEuclideanAlgorithm(
                        field,
                        field.buildMonomial(twoS, 1),
                        syndrome,
                        twoS
                    );
                    if (sigmaOmega === null) {
                        return null;
                    }
                    var errorLocations = findErrorLocations(
                        field,
                        sigmaOmega[0]
                    );
                    if (errorLocations == null) {
                        return null;
                    }
                    var errorMagnitudes = findErrorMagnitudes(
                        field,
                        sigmaOmega[1],
                        errorLocations
                    );
                    for (var i = 0; i < errorLocations.length; i++) {
                        var position =
                            outputBytes.length -
                            1 -
                            field.log(errorLocations[i]);
                        if (position < 0) {
                            return null;
                        }
                        outputBytes[position] = GenericGF_1.addOrSubtractGF(
                            outputBytes[position],
                            errorMagnitudes[i]
                        );
                    }
                    return outputBytes;
                }
                exports.decode = decode;

                /***/
            },
            /* 10 */
            /***/ function (module, exports, __webpack_require__) {
                "use strict";

                Object.defineProperty(exports, "__esModule", { value: true });
                exports.VERSIONS = [
                    {
                        infoBits: null,
                        versionNumber: 1,
                        alignmentPatternCenters: [],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 7,
                                ecBlocks: [
                                    { numBlocks: 1, dataCodewordsPerBlock: 19 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 10,
                                ecBlocks: [
                                    { numBlocks: 1, dataCodewordsPerBlock: 16 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 13,
                                ecBlocks: [
                                    { numBlocks: 1, dataCodewordsPerBlock: 13 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 17,
                                ecBlocks: [
                                    { numBlocks: 1, dataCodewordsPerBlock: 9 },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: null,
                        versionNumber: 2,
                        alignmentPatternCenters: [6, 18],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 10,
                                ecBlocks: [
                                    { numBlocks: 1, dataCodewordsPerBlock: 34 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 16,
                                ecBlocks: [
                                    { numBlocks: 1, dataCodewordsPerBlock: 28 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 22,
                                ecBlocks: [
                                    { numBlocks: 1, dataCodewordsPerBlock: 22 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    { numBlocks: 1, dataCodewordsPerBlock: 16 },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: null,
                        versionNumber: 3,
                        alignmentPatternCenters: [6, 22],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 15,
                                ecBlocks: [
                                    { numBlocks: 1, dataCodewordsPerBlock: 55 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 26,
                                ecBlocks: [
                                    { numBlocks: 1, dataCodewordsPerBlock: 44 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 18,
                                ecBlocks: [
                                    { numBlocks: 2, dataCodewordsPerBlock: 17 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 22,
                                ecBlocks: [
                                    { numBlocks: 2, dataCodewordsPerBlock: 13 },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: null,
                        versionNumber: 4,
                        alignmentPatternCenters: [6, 26],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 20,
                                ecBlocks: [
                                    { numBlocks: 1, dataCodewordsPerBlock: 80 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 18,
                                ecBlocks: [
                                    { numBlocks: 2, dataCodewordsPerBlock: 32 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 26,
                                ecBlocks: [
                                    { numBlocks: 2, dataCodewordsPerBlock: 24 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 16,
                                ecBlocks: [
                                    { numBlocks: 4, dataCodewordsPerBlock: 9 },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: null,
                        versionNumber: 5,
                        alignmentPatternCenters: [6, 30],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 26,
                                ecBlocks: [
                                    {
                                        numBlocks: 1,
                                        dataCodewordsPerBlock: 108,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 24,
                                ecBlocks: [
                                    { numBlocks: 2, dataCodewordsPerBlock: 43 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 18,
                                ecBlocks: [
                                    { numBlocks: 2, dataCodewordsPerBlock: 15 },
                                    { numBlocks: 2, dataCodewordsPerBlock: 16 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 22,
                                ecBlocks: [
                                    { numBlocks: 2, dataCodewordsPerBlock: 11 },
                                    { numBlocks: 2, dataCodewordsPerBlock: 12 },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: null,
                        versionNumber: 6,
                        alignmentPatternCenters: [6, 34],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 18,
                                ecBlocks: [
                                    { numBlocks: 2, dataCodewordsPerBlock: 68 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 16,
                                ecBlocks: [
                                    { numBlocks: 4, dataCodewordsPerBlock: 27 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 24,
                                ecBlocks: [
                                    { numBlocks: 4, dataCodewordsPerBlock: 19 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    { numBlocks: 4, dataCodewordsPerBlock: 15 },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x07c94,
                        versionNumber: 7,
                        alignmentPatternCenters: [6, 22, 38],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 20,
                                ecBlocks: [
                                    { numBlocks: 2, dataCodewordsPerBlock: 78 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 18,
                                ecBlocks: [
                                    { numBlocks: 4, dataCodewordsPerBlock: 31 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 18,
                                ecBlocks: [
                                    { numBlocks: 2, dataCodewordsPerBlock: 14 },
                                    { numBlocks: 4, dataCodewordsPerBlock: 15 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 26,
                                ecBlocks: [
                                    { numBlocks: 4, dataCodewordsPerBlock: 13 },
                                    { numBlocks: 1, dataCodewordsPerBlock: 14 },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x085bc,
                        versionNumber: 8,
                        alignmentPatternCenters: [6, 24, 42],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 24,
                                ecBlocks: [
                                    { numBlocks: 2, dataCodewordsPerBlock: 97 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 22,
                                ecBlocks: [
                                    { numBlocks: 2, dataCodewordsPerBlock: 38 },
                                    { numBlocks: 2, dataCodewordsPerBlock: 39 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 22,
                                ecBlocks: [
                                    { numBlocks: 4, dataCodewordsPerBlock: 18 },
                                    { numBlocks: 2, dataCodewordsPerBlock: 19 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 26,
                                ecBlocks: [
                                    { numBlocks: 4, dataCodewordsPerBlock: 14 },
                                    { numBlocks: 2, dataCodewordsPerBlock: 15 },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x09a99,
                        versionNumber: 9,
                        alignmentPatternCenters: [6, 26, 46],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 2,
                                        dataCodewordsPerBlock: 116,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 22,
                                ecBlocks: [
                                    { numBlocks: 3, dataCodewordsPerBlock: 36 },
                                    { numBlocks: 2, dataCodewordsPerBlock: 37 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 20,
                                ecBlocks: [
                                    { numBlocks: 4, dataCodewordsPerBlock: 16 },
                                    { numBlocks: 4, dataCodewordsPerBlock: 17 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 24,
                                ecBlocks: [
                                    { numBlocks: 4, dataCodewordsPerBlock: 12 },
                                    { numBlocks: 4, dataCodewordsPerBlock: 13 },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x0a4d3,
                        versionNumber: 10,
                        alignmentPatternCenters: [6, 28, 50],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 18,
                                ecBlocks: [
                                    { numBlocks: 2, dataCodewordsPerBlock: 68 },
                                    { numBlocks: 2, dataCodewordsPerBlock: 69 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 26,
                                ecBlocks: [
                                    { numBlocks: 4, dataCodewordsPerBlock: 43 },
                                    { numBlocks: 1, dataCodewordsPerBlock: 44 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 24,
                                ecBlocks: [
                                    { numBlocks: 6, dataCodewordsPerBlock: 19 },
                                    { numBlocks: 2, dataCodewordsPerBlock: 20 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    { numBlocks: 6, dataCodewordsPerBlock: 15 },
                                    { numBlocks: 2, dataCodewordsPerBlock: 16 },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x0bbf6,
                        versionNumber: 11,
                        alignmentPatternCenters: [6, 30, 54],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 20,
                                ecBlocks: [
                                    { numBlocks: 4, dataCodewordsPerBlock: 81 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    { numBlocks: 1, dataCodewordsPerBlock: 50 },
                                    { numBlocks: 4, dataCodewordsPerBlock: 51 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    { numBlocks: 4, dataCodewordsPerBlock: 22 },
                                    { numBlocks: 4, dataCodewordsPerBlock: 23 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 24,
                                ecBlocks: [
                                    { numBlocks: 3, dataCodewordsPerBlock: 12 },
                                    { numBlocks: 8, dataCodewordsPerBlock: 13 },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x0c762,
                        versionNumber: 12,
                        alignmentPatternCenters: [6, 32, 58],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 24,
                                ecBlocks: [
                                    { numBlocks: 2, dataCodewordsPerBlock: 92 },
                                    { numBlocks: 2, dataCodewordsPerBlock: 93 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 22,
                                ecBlocks: [
                                    { numBlocks: 6, dataCodewordsPerBlock: 36 },
                                    { numBlocks: 2, dataCodewordsPerBlock: 37 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 26,
                                ecBlocks: [
                                    { numBlocks: 4, dataCodewordsPerBlock: 20 },
                                    { numBlocks: 6, dataCodewordsPerBlock: 21 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    { numBlocks: 7, dataCodewordsPerBlock: 14 },
                                    { numBlocks: 4, dataCodewordsPerBlock: 15 },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x0d847,
                        versionNumber: 13,
                        alignmentPatternCenters: [6, 34, 62],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 26,
                                ecBlocks: [
                                    {
                                        numBlocks: 4,
                                        dataCodewordsPerBlock: 107,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 22,
                                ecBlocks: [
                                    { numBlocks: 8, dataCodewordsPerBlock: 37 },
                                    { numBlocks: 1, dataCodewordsPerBlock: 38 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 24,
                                ecBlocks: [
                                    { numBlocks: 8, dataCodewordsPerBlock: 20 },
                                    { numBlocks: 4, dataCodewordsPerBlock: 21 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 22,
                                ecBlocks: [
                                    {
                                        numBlocks: 12,
                                        dataCodewordsPerBlock: 11,
                                    },
                                    { numBlocks: 4, dataCodewordsPerBlock: 12 },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x0e60d,
                        versionNumber: 14,
                        alignmentPatternCenters: [6, 26, 46, 66],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 3,
                                        dataCodewordsPerBlock: 115,
                                    },
                                    {
                                        numBlocks: 1,
                                        dataCodewordsPerBlock: 116,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 24,
                                ecBlocks: [
                                    { numBlocks: 4, dataCodewordsPerBlock: 40 },
                                    { numBlocks: 5, dataCodewordsPerBlock: 41 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 20,
                                ecBlocks: [
                                    {
                                        numBlocks: 11,
                                        dataCodewordsPerBlock: 16,
                                    },
                                    { numBlocks: 5, dataCodewordsPerBlock: 17 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 24,
                                ecBlocks: [
                                    {
                                        numBlocks: 11,
                                        dataCodewordsPerBlock: 12,
                                    },
                                    { numBlocks: 5, dataCodewordsPerBlock: 13 },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x0f928,
                        versionNumber: 15,
                        alignmentPatternCenters: [6, 26, 48, 70],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 22,
                                ecBlocks: [
                                    { numBlocks: 5, dataCodewordsPerBlock: 87 },
                                    { numBlocks: 1, dataCodewordsPerBlock: 88 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 24,
                                ecBlocks: [
                                    { numBlocks: 5, dataCodewordsPerBlock: 41 },
                                    { numBlocks: 5, dataCodewordsPerBlock: 42 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    { numBlocks: 5, dataCodewordsPerBlock: 24 },
                                    { numBlocks: 7, dataCodewordsPerBlock: 25 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 24,
                                ecBlocks: [
                                    {
                                        numBlocks: 11,
                                        dataCodewordsPerBlock: 12,
                                    },
                                    { numBlocks: 7, dataCodewordsPerBlock: 13 },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x10b78,
                        versionNumber: 16,
                        alignmentPatternCenters: [6, 26, 50, 74],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 24,
                                ecBlocks: [
                                    { numBlocks: 5, dataCodewordsPerBlock: 98 },
                                    { numBlocks: 1, dataCodewordsPerBlock: 99 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    { numBlocks: 7, dataCodewordsPerBlock: 45 },
                                    { numBlocks: 3, dataCodewordsPerBlock: 46 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 24,
                                ecBlocks: [
                                    {
                                        numBlocks: 15,
                                        dataCodewordsPerBlock: 19,
                                    },
                                    { numBlocks: 2, dataCodewordsPerBlock: 20 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    { numBlocks: 3, dataCodewordsPerBlock: 15 },
                                    {
                                        numBlocks: 13,
                                        dataCodewordsPerBlock: 16,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x1145d,
                        versionNumber: 17,
                        alignmentPatternCenters: [6, 30, 54, 78],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 1,
                                        dataCodewordsPerBlock: 107,
                                    },
                                    {
                                        numBlocks: 5,
                                        dataCodewordsPerBlock: 108,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 10,
                                        dataCodewordsPerBlock: 46,
                                    },
                                    { numBlocks: 1, dataCodewordsPerBlock: 47 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    { numBlocks: 1, dataCodewordsPerBlock: 22 },
                                    {
                                        numBlocks: 15,
                                        dataCodewordsPerBlock: 23,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    { numBlocks: 2, dataCodewordsPerBlock: 14 },
                                    {
                                        numBlocks: 17,
                                        dataCodewordsPerBlock: 15,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x12a17,
                        versionNumber: 18,
                        alignmentPatternCenters: [6, 30, 56, 82],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 5,
                                        dataCodewordsPerBlock: 120,
                                    },
                                    {
                                        numBlocks: 1,
                                        dataCodewordsPerBlock: 121,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 26,
                                ecBlocks: [
                                    { numBlocks: 9, dataCodewordsPerBlock: 43 },
                                    { numBlocks: 4, dataCodewordsPerBlock: 44 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 17,
                                        dataCodewordsPerBlock: 22,
                                    },
                                    { numBlocks: 1, dataCodewordsPerBlock: 23 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    { numBlocks: 2, dataCodewordsPerBlock: 14 },
                                    {
                                        numBlocks: 19,
                                        dataCodewordsPerBlock: 15,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x13532,
                        versionNumber: 19,
                        alignmentPatternCenters: [6, 30, 58, 86],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 3,
                                        dataCodewordsPerBlock: 113,
                                    },
                                    {
                                        numBlocks: 4,
                                        dataCodewordsPerBlock: 114,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 26,
                                ecBlocks: [
                                    { numBlocks: 3, dataCodewordsPerBlock: 44 },
                                    {
                                        numBlocks: 11,
                                        dataCodewordsPerBlock: 45,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 26,
                                ecBlocks: [
                                    {
                                        numBlocks: 17,
                                        dataCodewordsPerBlock: 21,
                                    },
                                    { numBlocks: 4, dataCodewordsPerBlock: 22 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 26,
                                ecBlocks: [
                                    { numBlocks: 9, dataCodewordsPerBlock: 13 },
                                    {
                                        numBlocks: 16,
                                        dataCodewordsPerBlock: 14,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x149a6,
                        versionNumber: 20,
                        alignmentPatternCenters: [6, 34, 62, 90],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 3,
                                        dataCodewordsPerBlock: 107,
                                    },
                                    {
                                        numBlocks: 5,
                                        dataCodewordsPerBlock: 108,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 26,
                                ecBlocks: [
                                    { numBlocks: 3, dataCodewordsPerBlock: 41 },
                                    {
                                        numBlocks: 13,
                                        dataCodewordsPerBlock: 42,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 15,
                                        dataCodewordsPerBlock: 24,
                                    },
                                    { numBlocks: 5, dataCodewordsPerBlock: 25 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 15,
                                        dataCodewordsPerBlock: 15,
                                    },
                                    {
                                        numBlocks: 10,
                                        dataCodewordsPerBlock: 16,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x15683,
                        versionNumber: 21,
                        alignmentPatternCenters: [6, 28, 50, 72, 94],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 4,
                                        dataCodewordsPerBlock: 116,
                                    },
                                    {
                                        numBlocks: 4,
                                        dataCodewordsPerBlock: 117,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 26,
                                ecBlocks: [
                                    {
                                        numBlocks: 17,
                                        dataCodewordsPerBlock: 42,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 17,
                                        dataCodewordsPerBlock: 22,
                                    },
                                    { numBlocks: 6, dataCodewordsPerBlock: 23 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 19,
                                        dataCodewordsPerBlock: 16,
                                    },
                                    { numBlocks: 6, dataCodewordsPerBlock: 17 },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x168c9,
                        versionNumber: 22,
                        alignmentPatternCenters: [6, 26, 50, 74, 98],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 2,
                                        dataCodewordsPerBlock: 111,
                                    },
                                    {
                                        numBlocks: 7,
                                        dataCodewordsPerBlock: 112,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 17,
                                        dataCodewordsPerBlock: 46,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    { numBlocks: 7, dataCodewordsPerBlock: 24 },
                                    {
                                        numBlocks: 16,
                                        dataCodewordsPerBlock: 25,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 24,
                                ecBlocks: [
                                    {
                                        numBlocks: 34,
                                        dataCodewordsPerBlock: 13,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x177ec,
                        versionNumber: 23,
                        alignmentPatternCenters: [6, 30, 54, 74, 102],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 4,
                                        dataCodewordsPerBlock: 121,
                                    },
                                    {
                                        numBlocks: 5,
                                        dataCodewordsPerBlock: 122,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    { numBlocks: 4, dataCodewordsPerBlock: 47 },
                                    {
                                        numBlocks: 14,
                                        dataCodewordsPerBlock: 48,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 11,
                                        dataCodewordsPerBlock: 24,
                                    },
                                    {
                                        numBlocks: 14,
                                        dataCodewordsPerBlock: 25,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 16,
                                        dataCodewordsPerBlock: 15,
                                    },
                                    {
                                        numBlocks: 14,
                                        dataCodewordsPerBlock: 16,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x18ec4,
                        versionNumber: 24,
                        alignmentPatternCenters: [6, 28, 54, 80, 106],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 6,
                                        dataCodewordsPerBlock: 117,
                                    },
                                    {
                                        numBlocks: 4,
                                        dataCodewordsPerBlock: 118,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    { numBlocks: 6, dataCodewordsPerBlock: 45 },
                                    {
                                        numBlocks: 14,
                                        dataCodewordsPerBlock: 46,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 11,
                                        dataCodewordsPerBlock: 24,
                                    },
                                    {
                                        numBlocks: 16,
                                        dataCodewordsPerBlock: 25,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 30,
                                        dataCodewordsPerBlock: 16,
                                    },
                                    { numBlocks: 2, dataCodewordsPerBlock: 17 },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x191e1,
                        versionNumber: 25,
                        alignmentPatternCenters: [6, 32, 58, 84, 110],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 26,
                                ecBlocks: [
                                    {
                                        numBlocks: 8,
                                        dataCodewordsPerBlock: 106,
                                    },
                                    {
                                        numBlocks: 4,
                                        dataCodewordsPerBlock: 107,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    { numBlocks: 8, dataCodewordsPerBlock: 47 },
                                    {
                                        numBlocks: 13,
                                        dataCodewordsPerBlock: 48,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    { numBlocks: 7, dataCodewordsPerBlock: 24 },
                                    {
                                        numBlocks: 22,
                                        dataCodewordsPerBlock: 25,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 22,
                                        dataCodewordsPerBlock: 15,
                                    },
                                    {
                                        numBlocks: 13,
                                        dataCodewordsPerBlock: 16,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x1afab,
                        versionNumber: 26,
                        alignmentPatternCenters: [6, 30, 58, 86, 114],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 10,
                                        dataCodewordsPerBlock: 114,
                                    },
                                    {
                                        numBlocks: 2,
                                        dataCodewordsPerBlock: 115,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 19,
                                        dataCodewordsPerBlock: 46,
                                    },
                                    { numBlocks: 4, dataCodewordsPerBlock: 47 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 28,
                                        dataCodewordsPerBlock: 22,
                                    },
                                    { numBlocks: 6, dataCodewordsPerBlock: 23 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 33,
                                        dataCodewordsPerBlock: 16,
                                    },
                                    { numBlocks: 4, dataCodewordsPerBlock: 17 },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x1b08e,
                        versionNumber: 27,
                        alignmentPatternCenters: [6, 34, 62, 90, 118],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 8,
                                        dataCodewordsPerBlock: 122,
                                    },
                                    {
                                        numBlocks: 4,
                                        dataCodewordsPerBlock: 123,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 22,
                                        dataCodewordsPerBlock: 45,
                                    },
                                    { numBlocks: 3, dataCodewordsPerBlock: 46 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    { numBlocks: 8, dataCodewordsPerBlock: 23 },
                                    {
                                        numBlocks: 26,
                                        dataCodewordsPerBlock: 24,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 12,
                                        dataCodewordsPerBlock: 15,
                                    },
                                    {
                                        numBlocks: 28,
                                        dataCodewordsPerBlock: 16,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x1cc1a,
                        versionNumber: 28,
                        alignmentPatternCenters: [6, 26, 50, 74, 98, 122],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 3,
                                        dataCodewordsPerBlock: 117,
                                    },
                                    {
                                        numBlocks: 10,
                                        dataCodewordsPerBlock: 118,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    { numBlocks: 3, dataCodewordsPerBlock: 45 },
                                    {
                                        numBlocks: 23,
                                        dataCodewordsPerBlock: 46,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    { numBlocks: 4, dataCodewordsPerBlock: 24 },
                                    {
                                        numBlocks: 31,
                                        dataCodewordsPerBlock: 25,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 11,
                                        dataCodewordsPerBlock: 15,
                                    },
                                    {
                                        numBlocks: 31,
                                        dataCodewordsPerBlock: 16,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x1d33f,
                        versionNumber: 29,
                        alignmentPatternCenters: [6, 30, 54, 78, 102, 126],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 7,
                                        dataCodewordsPerBlock: 116,
                                    },
                                    {
                                        numBlocks: 7,
                                        dataCodewordsPerBlock: 117,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 21,
                                        dataCodewordsPerBlock: 45,
                                    },
                                    { numBlocks: 7, dataCodewordsPerBlock: 46 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    { numBlocks: 1, dataCodewordsPerBlock: 23 },
                                    {
                                        numBlocks: 37,
                                        dataCodewordsPerBlock: 24,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 19,
                                        dataCodewordsPerBlock: 15,
                                    },
                                    {
                                        numBlocks: 26,
                                        dataCodewordsPerBlock: 16,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x1ed75,
                        versionNumber: 30,
                        alignmentPatternCenters: [6, 26, 52, 78, 104, 130],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 5,
                                        dataCodewordsPerBlock: 115,
                                    },
                                    {
                                        numBlocks: 10,
                                        dataCodewordsPerBlock: 116,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 19,
                                        dataCodewordsPerBlock: 47,
                                    },
                                    {
                                        numBlocks: 10,
                                        dataCodewordsPerBlock: 48,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 15,
                                        dataCodewordsPerBlock: 24,
                                    },
                                    {
                                        numBlocks: 25,
                                        dataCodewordsPerBlock: 25,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 23,
                                        dataCodewordsPerBlock: 15,
                                    },
                                    {
                                        numBlocks: 25,
                                        dataCodewordsPerBlock: 16,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x1f250,
                        versionNumber: 31,
                        alignmentPatternCenters: [6, 30, 56, 82, 108, 134],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 13,
                                        dataCodewordsPerBlock: 115,
                                    },
                                    {
                                        numBlocks: 3,
                                        dataCodewordsPerBlock: 116,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    { numBlocks: 2, dataCodewordsPerBlock: 46 },
                                    {
                                        numBlocks: 29,
                                        dataCodewordsPerBlock: 47,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 42,
                                        dataCodewordsPerBlock: 24,
                                    },
                                    { numBlocks: 1, dataCodewordsPerBlock: 25 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 23,
                                        dataCodewordsPerBlock: 15,
                                    },
                                    {
                                        numBlocks: 28,
                                        dataCodewordsPerBlock: 16,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x209d5,
                        versionNumber: 32,
                        alignmentPatternCenters: [6, 34, 60, 86, 112, 138],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 17,
                                        dataCodewordsPerBlock: 115,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 10,
                                        dataCodewordsPerBlock: 46,
                                    },
                                    {
                                        numBlocks: 23,
                                        dataCodewordsPerBlock: 47,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 10,
                                        dataCodewordsPerBlock: 24,
                                    },
                                    {
                                        numBlocks: 35,
                                        dataCodewordsPerBlock: 25,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 19,
                                        dataCodewordsPerBlock: 15,
                                    },
                                    {
                                        numBlocks: 35,
                                        dataCodewordsPerBlock: 16,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x216f0,
                        versionNumber: 33,
                        alignmentPatternCenters: [6, 30, 58, 86, 114, 142],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 17,
                                        dataCodewordsPerBlock: 115,
                                    },
                                    {
                                        numBlocks: 1,
                                        dataCodewordsPerBlock: 116,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 14,
                                        dataCodewordsPerBlock: 46,
                                    },
                                    {
                                        numBlocks: 21,
                                        dataCodewordsPerBlock: 47,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 29,
                                        dataCodewordsPerBlock: 24,
                                    },
                                    {
                                        numBlocks: 19,
                                        dataCodewordsPerBlock: 25,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 11,
                                        dataCodewordsPerBlock: 15,
                                    },
                                    {
                                        numBlocks: 46,
                                        dataCodewordsPerBlock: 16,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x228ba,
                        versionNumber: 34,
                        alignmentPatternCenters: [6, 34, 62, 90, 118, 146],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 13,
                                        dataCodewordsPerBlock: 115,
                                    },
                                    {
                                        numBlocks: 6,
                                        dataCodewordsPerBlock: 116,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 14,
                                        dataCodewordsPerBlock: 46,
                                    },
                                    {
                                        numBlocks: 23,
                                        dataCodewordsPerBlock: 47,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 44,
                                        dataCodewordsPerBlock: 24,
                                    },
                                    { numBlocks: 7, dataCodewordsPerBlock: 25 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 59,
                                        dataCodewordsPerBlock: 16,
                                    },
                                    { numBlocks: 1, dataCodewordsPerBlock: 17 },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x2379f,
                        versionNumber: 35,
                        alignmentPatternCenters: [6, 30, 54, 78, 102, 126, 150],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 12,
                                        dataCodewordsPerBlock: 121,
                                    },
                                    {
                                        numBlocks: 7,
                                        dataCodewordsPerBlock: 122,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 12,
                                        dataCodewordsPerBlock: 47,
                                    },
                                    {
                                        numBlocks: 26,
                                        dataCodewordsPerBlock: 48,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 39,
                                        dataCodewordsPerBlock: 24,
                                    },
                                    {
                                        numBlocks: 14,
                                        dataCodewordsPerBlock: 25,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 22,
                                        dataCodewordsPerBlock: 15,
                                    },
                                    {
                                        numBlocks: 41,
                                        dataCodewordsPerBlock: 16,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x24b0b,
                        versionNumber: 36,
                        alignmentPatternCenters: [6, 24, 50, 76, 102, 128, 154],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 6,
                                        dataCodewordsPerBlock: 121,
                                    },
                                    {
                                        numBlocks: 14,
                                        dataCodewordsPerBlock: 122,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    { numBlocks: 6, dataCodewordsPerBlock: 47 },
                                    {
                                        numBlocks: 34,
                                        dataCodewordsPerBlock: 48,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 46,
                                        dataCodewordsPerBlock: 24,
                                    },
                                    {
                                        numBlocks: 10,
                                        dataCodewordsPerBlock: 25,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    { numBlocks: 2, dataCodewordsPerBlock: 15 },
                                    {
                                        numBlocks: 64,
                                        dataCodewordsPerBlock: 16,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x2542e,
                        versionNumber: 37,
                        alignmentPatternCenters: [6, 28, 54, 80, 106, 132, 158],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 17,
                                        dataCodewordsPerBlock: 122,
                                    },
                                    {
                                        numBlocks: 4,
                                        dataCodewordsPerBlock: 123,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 29,
                                        dataCodewordsPerBlock: 46,
                                    },
                                    {
                                        numBlocks: 14,
                                        dataCodewordsPerBlock: 47,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 49,
                                        dataCodewordsPerBlock: 24,
                                    },
                                    {
                                        numBlocks: 10,
                                        dataCodewordsPerBlock: 25,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 24,
                                        dataCodewordsPerBlock: 15,
                                    },
                                    {
                                        numBlocks: 46,
                                        dataCodewordsPerBlock: 16,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x26a64,
                        versionNumber: 38,
                        alignmentPatternCenters: [6, 32, 58, 84, 110, 136, 162],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 4,
                                        dataCodewordsPerBlock: 122,
                                    },
                                    {
                                        numBlocks: 18,
                                        dataCodewordsPerBlock: 123,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 13,
                                        dataCodewordsPerBlock: 46,
                                    },
                                    {
                                        numBlocks: 32,
                                        dataCodewordsPerBlock: 47,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 48,
                                        dataCodewordsPerBlock: 24,
                                    },
                                    {
                                        numBlocks: 14,
                                        dataCodewordsPerBlock: 25,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 42,
                                        dataCodewordsPerBlock: 15,
                                    },
                                    {
                                        numBlocks: 32,
                                        dataCodewordsPerBlock: 16,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x27541,
                        versionNumber: 39,
                        alignmentPatternCenters: [6, 26, 54, 82, 110, 138, 166],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 20,
                                        dataCodewordsPerBlock: 117,
                                    },
                                    {
                                        numBlocks: 4,
                                        dataCodewordsPerBlock: 118,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 40,
                                        dataCodewordsPerBlock: 47,
                                    },
                                    { numBlocks: 7, dataCodewordsPerBlock: 48 },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 43,
                                        dataCodewordsPerBlock: 24,
                                    },
                                    {
                                        numBlocks: 22,
                                        dataCodewordsPerBlock: 25,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 10,
                                        dataCodewordsPerBlock: 15,
                                    },
                                    {
                                        numBlocks: 67,
                                        dataCodewordsPerBlock: 16,
                                    },
                                ],
                            },
                        ],
                    },
                    {
                        infoBits: 0x28c69,
                        versionNumber: 40,
                        alignmentPatternCenters: [6, 30, 58, 86, 114, 142, 170],
                        errorCorrectionLevels: [
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 19,
                                        dataCodewordsPerBlock: 118,
                                    },
                                    {
                                        numBlocks: 6,
                                        dataCodewordsPerBlock: 119,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 28,
                                ecBlocks: [
                                    {
                                        numBlocks: 18,
                                        dataCodewordsPerBlock: 47,
                                    },
                                    {
                                        numBlocks: 31,
                                        dataCodewordsPerBlock: 48,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 34,
                                        dataCodewordsPerBlock: 24,
                                    },
                                    {
                                        numBlocks: 34,
                                        dataCodewordsPerBlock: 25,
                                    },
                                ],
                            },
                            {
                                ecCodewordsPerBlock: 30,
                                ecBlocks: [
                                    {
                                        numBlocks: 20,
                                        dataCodewordsPerBlock: 15,
                                    },
                                    {
                                        numBlocks: 61,
                                        dataCodewordsPerBlock: 16,
                                    },
                                ],
                            },
                        ],
                    },
                ];

                /***/
            },
            /* 11 */
            /***/ function (module, exports, __webpack_require__) {
                "use strict";

                Object.defineProperty(exports, "__esModule", { value: true });
                var BitMatrix_1 = __webpack_require__(0);
                function squareToQuadrilateral(p1, p2, p3, p4) {
                    var dx3 = p1.x - p2.x + p3.x - p4.x;
                    var dy3 = p1.y - p2.y + p3.y - p4.y;
                    if (dx3 === 0 && dy3 === 0) {
                        // Affine
                        return {
                            a11: p2.x - p1.x,
                            a12: p2.y - p1.y,
                            a13: 0,
                            a21: p3.x - p2.x,
                            a22: p3.y - p2.y,
                            a23: 0,
                            a31: p1.x,
                            a32: p1.y,
                            a33: 1,
                        };
                    } else {
                        var dx1 = p2.x - p3.x;
                        var dx2 = p4.x - p3.x;
                        var dy1 = p2.y - p3.y;
                        var dy2 = p4.y - p3.y;
                        var denominator = dx1 * dy2 - dx2 * dy1;
                        var a13 = (dx3 * dy2 - dx2 * dy3) / denominator;
                        var a23 = (dx1 * dy3 - dx3 * dy1) / denominator;
                        return {
                            a11: p2.x - p1.x + a13 * p2.x,
                            a12: p2.y - p1.y + a13 * p2.y,
                            a13: a13,
                            a21: p4.x - p1.x + a23 * p4.x,
                            a22: p4.y - p1.y + a23 * p4.y,
                            a23: a23,
                            a31: p1.x,
                            a32: p1.y,
                            a33: 1,
                        };
                    }
                }
                function quadrilateralToSquare(p1, p2, p3, p4) {
                    // Here, the adjoint serves as the inverse:
                    var sToQ = squareToQuadrilateral(p1, p2, p3, p4);
                    return {
                        a11: sToQ.a22 * sToQ.a33 - sToQ.a23 * sToQ.a32,
                        a12: sToQ.a13 * sToQ.a32 - sToQ.a12 * sToQ.a33,
                        a13: sToQ.a12 * sToQ.a23 - sToQ.a13 * sToQ.a22,
                        a21: sToQ.a23 * sToQ.a31 - sToQ.a21 * sToQ.a33,
                        a22: sToQ.a11 * sToQ.a33 - sToQ.a13 * sToQ.a31,
                        a23: sToQ.a13 * sToQ.a21 - sToQ.a11 * sToQ.a23,
                        a31: sToQ.a21 * sToQ.a32 - sToQ.a22 * sToQ.a31,
                        a32: sToQ.a12 * sToQ.a31 - sToQ.a11 * sToQ.a32,
                        a33: sToQ.a11 * sToQ.a22 - sToQ.a12 * sToQ.a21,
                    };
                }
                function times(a, b) {
                    return {
                        a11: a.a11 * b.a11 + a.a21 * b.a12 + a.a31 * b.a13,
                        a12: a.a12 * b.a11 + a.a22 * b.a12 + a.a32 * b.a13,
                        a13: a.a13 * b.a11 + a.a23 * b.a12 + a.a33 * b.a13,
                        a21: a.a11 * b.a21 + a.a21 * b.a22 + a.a31 * b.a23,
                        a22: a.a12 * b.a21 + a.a22 * b.a22 + a.a32 * b.a23,
                        a23: a.a13 * b.a21 + a.a23 * b.a22 + a.a33 * b.a23,
                        a31: a.a11 * b.a31 + a.a21 * b.a32 + a.a31 * b.a33,
                        a32: a.a12 * b.a31 + a.a22 * b.a32 + a.a32 * b.a33,
                        a33: a.a13 * b.a31 + a.a23 * b.a32 + a.a33 * b.a33,
                    };
                }
                function extract(image, location) {
                    var qToS = quadrilateralToSquare(
                        { x: 3.5, y: 3.5 },
                        { x: location.dimension - 3.5, y: 3.5 },
                        {
                            x: location.dimension - 6.5,
                            y: location.dimension - 6.5,
                        },
                        { x: 3.5, y: location.dimension - 3.5 }
                    );
                    var sToQ = squareToQuadrilateral(
                        location.topLeft,
                        location.topRight,
                        location.alignmentPattern,
                        location.bottomLeft
                    );
                    var transform = times(sToQ, qToS);
                    var matrix = BitMatrix_1.BitMatrix.createEmpty(
                        location.dimension,
                        location.dimension
                    );
                    var mappingFunction = function (x, y) {
                        var denominator =
                            transform.a13 * x +
                            transform.a23 * y +
                            transform.a33;
                        return {
                            x:
                                (transform.a11 * x +
                                    transform.a21 * y +
                                    transform.a31) /
                                denominator,
                            y:
                                (transform.a12 * x +
                                    transform.a22 * y +
                                    transform.a32) /
                                denominator,
                        };
                    };
                    for (var y = 0; y < location.dimension; y++) {
                        for (var x = 0; x < location.dimension; x++) {
                            var xValue = x + 0.5;
                            var yValue = y + 0.5;
                            var sourcePixel = mappingFunction(xValue, yValue);
                            matrix.set(
                                x,
                                y,
                                image.get(
                                    Math.floor(sourcePixel.x),
                                    Math.floor(sourcePixel.y)
                                )
                            );
                        }
                    }
                    return {
                        matrix: matrix,
                        mappingFunction: mappingFunction,
                    };
                }
                exports.extract = extract;

                /***/
            },
            /* 12 */
            /***/ function (module, exports, __webpack_require__) {
                "use strict";

                Object.defineProperty(exports, "__esModule", { value: true });
                var MAX_FINDERPATTERNS_TO_SEARCH = 4;
                var MIN_QUAD_RATIO = 0.5;
                var MAX_QUAD_RATIO = 1.5;
                var distance = function (a, b) {
                    return Math.sqrt(
                        Math.pow(b.x - a.x, 2) + Math.pow(b.y - a.y, 2)
                    );
                };
                function sum(values) {
                    return values.reduce(function (a, b) {
                        return a + b;
                    });
                }
                // Takes three finder patterns and organizes them into topLeft, topRight, etc
                function reorderFinderPatterns(pattern1, pattern2, pattern3) {
                    var _a, _b, _c, _d;
                    // Find distances between pattern centers
                    var oneTwoDistance = distance(pattern1, pattern2);
                    var twoThreeDistance = distance(pattern2, pattern3);
                    var oneThreeDistance = distance(pattern1, pattern3);
                    var bottomLeft;
                    var topLeft;
                    var topRight;
                    // Assume one closest to other two is B; A and C will just be guesses at first
                    if (
                        twoThreeDistance >= oneTwoDistance &&
                        twoThreeDistance >= oneThreeDistance
                    ) {
                        (_a = [pattern2, pattern1, pattern3]),
                            (bottomLeft = _a[0]),
                            (topLeft = _a[1]),
                            (topRight = _a[2]);
                    } else if (
                        oneThreeDistance >= twoThreeDistance &&
                        oneThreeDistance >= oneTwoDistance
                    ) {
                        (_b = [pattern1, pattern2, pattern3]),
                            (bottomLeft = _b[0]),
                            (topLeft = _b[1]),
                            (topRight = _b[2]);
                    } else {
                        (_c = [pattern1, pattern3, pattern2]),
                            (bottomLeft = _c[0]),
                            (topLeft = _c[1]),
                            (topRight = _c[2]);
                    }
                    // Use cross product to figure out whether bottomLeft (A) and topRight (C) are correct or flipped in relation to topLeft (B)
                    // This asks whether BC x BA has a positive z component, which is the arrangement we want. If it's negative, then
                    // we've got it flipped around and should swap topRight and bottomLeft.
                    if (
                        (topRight.x - topLeft.x) * (bottomLeft.y - topLeft.y) -
                            (topRight.y - topLeft.y) *
                                (bottomLeft.x - topLeft.x) <
                        0
                    ) {
                        (_d = [topRight, bottomLeft]),
                            (bottomLeft = _d[0]),
                            (topRight = _d[1]);
                    }
                    return {
                        bottomLeft: bottomLeft,
                        topLeft: topLeft,
                        topRight: topRight,
                    };
                }
                // Computes the dimension (number of modules on a side) of the QR Code based on the position of the finder patterns
                function computeDimension(
                    topLeft,
                    topRight,
                    bottomLeft,
                    matrix
                ) {
                    var moduleSize =
                        (sum(
                            countBlackWhiteRun(topLeft, bottomLeft, matrix, 5)
                        ) /
                            7 + // Divide by 7 since the ratio is 1:1:3:1:1
                            sum(
                                countBlackWhiteRun(topLeft, topRight, matrix, 5)
                            ) /
                                7 +
                            sum(
                                countBlackWhiteRun(
                                    bottomLeft,
                                    topLeft,
                                    matrix,
                                    5
                                )
                            ) /
                                7 +
                            sum(
                                countBlackWhiteRun(topRight, topLeft, matrix, 5)
                            ) /
                                7) /
                        4;
                    if (moduleSize < 1) {
                        throw new Error("Invalid module size");
                    }
                    var topDimension = Math.round(
                        distance(topLeft, topRight) / moduleSize
                    );
                    var sideDimension = Math.round(
                        distance(topLeft, bottomLeft) / moduleSize
                    );
                    var dimension =
                        Math.floor((topDimension + sideDimension) / 2) + 7;
                    switch (dimension % 4) {
                        case 0:
                            dimension++;
                            break;
                        case 2:
                            dimension--;
                            break;
                    }
                    return { dimension: dimension, moduleSize: moduleSize };
                }
                // Takes an origin point and an end point and counts the sizes of the black white run from the origin towards the end point.
                // Returns an array of elements, representing the pixel size of the black white run.
                // Uses a variant of http://en.wikipedia.org/wiki/Bresenham's_line_algorithm
                function countBlackWhiteRunTowardsPoint(
                    origin,
                    end,
                    matrix,
                    length
                ) {
                    var switchPoints = [
                        { x: Math.floor(origin.x), y: Math.floor(origin.y) },
                    ];
                    var steep =
                        Math.abs(end.y - origin.y) > Math.abs(end.x - origin.x);
                    var fromX;
                    var fromY;
                    var toX;
                    var toY;
                    if (steep) {
                        fromX = Math.floor(origin.y);
                        fromY = Math.floor(origin.x);
                        toX = Math.floor(end.y);
                        toY = Math.floor(end.x);
                    } else {
                        fromX = Math.floor(origin.x);
                        fromY = Math.floor(origin.y);
                        toX = Math.floor(end.x);
                        toY = Math.floor(end.y);
                    }
                    var dx = Math.abs(toX - fromX);
                    var dy = Math.abs(toY - fromY);
                    var error = Math.floor(-dx / 2);
                    var xStep = fromX < toX ? 1 : -1;
                    var yStep = fromY < toY ? 1 : -1;
                    var currentPixel = true;
                    // Loop up until x == toX, but not beyond
                    for (
                        var x = fromX, y = fromY;
                        x !== toX + xStep;
                        x += xStep
                    ) {
                        // Does current pixel mean we have moved white to black or vice versa?
                        // Scanning black in state 0,2 and white in state 1, so if we find the wrong
                        // color, advance to next state or end if we are in state 2 already
                        var realX = steep ? y : x;
                        var realY = steep ? x : y;
                        if (matrix.get(realX, realY) !== currentPixel) {
                            currentPixel = !currentPixel;
                            switchPoints.push({ x: realX, y: realY });
                            if (switchPoints.length === length + 1) {
                                break;
                            }
                        }
                        error += dy;
                        if (error > 0) {
                            if (y === toY) {
                                break;
                            }
                            y += yStep;
                            error -= dx;
                        }
                    }
                    var distances = [];
                    for (var i = 0; i < length; i++) {
                        if (switchPoints[i] && switchPoints[i + 1]) {
                            distances.push(
                                distance(switchPoints[i], switchPoints[i + 1])
                            );
                        } else {
                            distances.push(0);
                        }
                    }
                    return distances;
                }
                // Takes an origin point and an end point and counts the sizes of the black white run in the origin point
                // along the line that intersects with the end point. Returns an array of elements, representing the pixel sizes
                // of the black white run. Takes a length which represents the number of switches from black to white to look for.
                function countBlackWhiteRun(origin, end, matrix, length) {
                    var _a;
                    var rise = end.y - origin.y;
                    var run = end.x - origin.x;
                    var towardsEnd = countBlackWhiteRunTowardsPoint(
                        origin,
                        end,
                        matrix,
                        Math.ceil(length / 2)
                    );
                    var awayFromEnd = countBlackWhiteRunTowardsPoint(
                        origin,
                        { x: origin.x - run, y: origin.y - rise },
                        matrix,
                        Math.ceil(length / 2)
                    );
                    var middleValue =
                        towardsEnd.shift() + awayFromEnd.shift() - 1; // Substract one so we don't double count a pixel
                    return (_a = awayFromEnd.concat(middleValue)).concat.apply(
                        _a,
                        towardsEnd
                    );
                }
                // Takes in a black white run and an array of expected ratios. Returns the average size of the run as well as the "error" -
                // that is the amount the run diverges from the expected ratio
                function scoreBlackWhiteRun(sequence, ratios) {
                    var averageSize = sum(sequence) / sum(ratios);
                    var error = 0;
                    ratios.forEach(function (ratio, i) {
                        error += Math.pow(sequence[i] - ratio * averageSize, 2);
                    });
                    return { averageSize: averageSize, error: error };
                }
                // Takes an X,Y point and an array of sizes and scores the point against those ratios.
                // For example for a finder pattern takes the ratio list of 1:1:3:1:1 and checks horizontal, vertical and diagonal ratios
                // against that.
                function scorePattern(point, ratios, matrix) {
                    try {
                        var horizontalRun = countBlackWhiteRun(
                            point,
                            { x: -1, y: point.y },
                            matrix,
                            ratios.length
                        );
                        var verticalRun = countBlackWhiteRun(
                            point,
                            { x: point.x, y: -1 },
                            matrix,
                            ratios.length
                        );
                        var topLeftPoint = {
                            x: Math.max(0, point.x - point.y) - 1,
                            y: Math.max(0, point.y - point.x) - 1,
                        };
                        var topLeftBottomRightRun = countBlackWhiteRun(
                            point,
                            topLeftPoint,
                            matrix,
                            ratios.length
                        );
                        var bottomLeftPoint = {
                            x: Math.min(matrix.width, point.x + point.y) + 1,
                            y: Math.min(matrix.height, point.y + point.x) + 1,
                        };
                        var bottomLeftTopRightRun = countBlackWhiteRun(
                            point,
                            bottomLeftPoint,
                            matrix,
                            ratios.length
                        );
                        var horzError = scoreBlackWhiteRun(
                            horizontalRun,
                            ratios
                        );
                        var vertError = scoreBlackWhiteRun(verticalRun, ratios);
                        var diagDownError = scoreBlackWhiteRun(
                            topLeftBottomRightRun,
                            ratios
                        );
                        var diagUpError = scoreBlackWhiteRun(
                            bottomLeftTopRightRun,
                            ratios
                        );
                        var ratioError = Math.sqrt(
                            horzError.error * horzError.error +
                                vertError.error * vertError.error +
                                diagDownError.error * diagDownError.error +
                                diagUpError.error * diagUpError.error
                        );
                        var avgSize =
                            (horzError.averageSize +
                                vertError.averageSize +
                                diagDownError.averageSize +
                                diagUpError.averageSize) /
                            4;
                        var sizeError =
                            (Math.pow(horzError.averageSize - avgSize, 2) +
                                Math.pow(vertError.averageSize - avgSize, 2) +
                                Math.pow(
                                    diagDownError.averageSize - avgSize,
                                    2
                                ) +
                                Math.pow(
                                    diagUpError.averageSize - avgSize,
                                    2
                                )) /
                            avgSize;
                        return ratioError + sizeError;
                    } catch (_a) {
                        return Infinity;
                    }
                }
                function recenterLocation(matrix, p) {
                    var leftX = Math.round(p.x);
                    while (matrix.get(leftX, Math.round(p.y))) {
                        leftX--;
                    }
                    var rightX = Math.round(p.x);
                    while (matrix.get(rightX, Math.round(p.y))) {
                        rightX++;
                    }
                    var x = (leftX + rightX) / 2;
                    var topY = Math.round(p.y);
                    while (matrix.get(Math.round(x), topY)) {
                        topY--;
                    }
                    var bottomY = Math.round(p.y);
                    while (matrix.get(Math.round(x), bottomY)) {
                        bottomY++;
                    }
                    var y = (topY + bottomY) / 2;
                    return { x: x, y: y };
                }
                function locate(matrix) {
                    var finderPatternQuads = [];
                    var activeFinderPatternQuads = [];
                    var alignmentPatternQuads = [];
                    var activeAlignmentPatternQuads = [];
                    var _loop_1 = function (y) {
                        var length_1 = 0;
                        var lastBit = false;
                        var scans = [0, 0, 0, 0, 0];
                        var _loop_2 = function (x) {
                            var v = matrix.get(x, y);
                            if (v === lastBit) {
                                length_1++;
                            } else {
                                scans = [
                                    scans[1],
                                    scans[2],
                                    scans[3],
                                    scans[4],
                                    length_1,
                                ];
                                length_1 = 1;
                                lastBit = v;
                                // Do the last 5 color changes ~ match the expected ratio for a finder pattern? 1:1:3:1:1 of b:w:b:w:b
                                var averageFinderPatternBlocksize =
                                    sum(scans) / 7;
                                var validFinderPattern =
                                    Math.abs(
                                        scans[0] - averageFinderPatternBlocksize
                                    ) < averageFinderPatternBlocksize &&
                                    Math.abs(
                                        scans[1] - averageFinderPatternBlocksize
                                    ) < averageFinderPatternBlocksize &&
                                    Math.abs(
                                        scans[2] -
                                            3 * averageFinderPatternBlocksize
                                    ) <
                                        3 * averageFinderPatternBlocksize &&
                                    Math.abs(
                                        scans[3] - averageFinderPatternBlocksize
                                    ) < averageFinderPatternBlocksize &&
                                    Math.abs(
                                        scans[4] - averageFinderPatternBlocksize
                                    ) < averageFinderPatternBlocksize &&
                                    !v; // And make sure the current pixel is white since finder patterns are bordered in white
                                // Do the last 3 color changes ~ match the expected ratio for an alignment pattern? 1:1:1 of w:b:w
                                var averageAlignmentPatternBlocksize =
                                    sum(scans.slice(-3)) / 3;
                                var validAlignmentPattern =
                                    Math.abs(
                                        scans[2] -
                                            averageAlignmentPatternBlocksize
                                    ) < averageAlignmentPatternBlocksize &&
                                    Math.abs(
                                        scans[3] -
                                            averageAlignmentPatternBlocksize
                                    ) < averageAlignmentPatternBlocksize &&
                                    Math.abs(
                                        scans[4] -
                                            averageAlignmentPatternBlocksize
                                    ) < averageAlignmentPatternBlocksize &&
                                    v; // Is the current pixel black since alignment patterns are bordered in black
                                if (validFinderPattern) {
                                    // Compute the start and end x values of the large center black square
                                    var endX_1 = x - scans[3] - scans[4];
                                    var startX_1 = endX_1 - scans[2];
                                    var line = {
                                        startX: startX_1,
                                        endX: endX_1,
                                        y: y,
                                    };
                                    // Is there a quad directly above the current spot? If so, extend it with the new line. Otherwise, create a new quad with
                                    // that line as the starting point.
                                    var matchingQuads =
                                        activeFinderPatternQuads.filter(
                                            function (q) {
                                                return (
                                                    (startX_1 >=
                                                        q.bottom.startX &&
                                                        startX_1 <=
                                                            q.bottom.endX) ||
                                                    (endX_1 >=
                                                        q.bottom.startX &&
                                                        startX_1 <=
                                                            q.bottom.endX) ||
                                                    (startX_1 <=
                                                        q.bottom.startX &&
                                                        endX_1 >=
                                                            q.bottom.endX &&
                                                        scans[2] /
                                                            (q.bottom.endX -
                                                                q.bottom
                                                                    .startX) <
                                                            MAX_QUAD_RATIO &&
                                                        scans[2] /
                                                            (q.bottom.endX -
                                                                q.bottom
                                                                    .startX) >
                                                            MIN_QUAD_RATIO)
                                                );
                                            }
                                        );
                                    if (matchingQuads.length > 0) {
                                        matchingQuads[0].bottom = line;
                                    } else {
                                        activeFinderPatternQuads.push({
                                            top: line,
                                            bottom: line,
                                        });
                                    }
                                }
                                if (validAlignmentPattern) {
                                    // Compute the start and end x values of the center black square
                                    var endX_2 = x - scans[4];
                                    var startX_2 = endX_2 - scans[3];
                                    var line = {
                                        startX: startX_2,
                                        y: y,
                                        endX: endX_2,
                                    };
                                    // Is there a quad directly above the current spot? If so, extend it with the new line. Otherwise, create a new quad with
                                    // that line as the starting point.
                                    var matchingQuads =
                                        activeAlignmentPatternQuads.filter(
                                            function (q) {
                                                return (
                                                    (startX_2 >=
                                                        q.bottom.startX &&
                                                        startX_2 <=
                                                            q.bottom.endX) ||
                                                    (endX_2 >=
                                                        q.bottom.startX &&
                                                        startX_2 <=
                                                            q.bottom.endX) ||
                                                    (startX_2 <=
                                                        q.bottom.startX &&
                                                        endX_2 >=
                                                            q.bottom.endX &&
                                                        scans[2] /
                                                            (q.bottom.endX -
                                                                q.bottom
                                                                    .startX) <
                                                            MAX_QUAD_RATIO &&
                                                        scans[2] /
                                                            (q.bottom.endX -
                                                                q.bottom
                                                                    .startX) >
                                                            MIN_QUAD_RATIO)
                                                );
                                            }
                                        );
                                    if (matchingQuads.length > 0) {
                                        matchingQuads[0].bottom = line;
                                    } else {
                                        activeAlignmentPatternQuads.push({
                                            top: line,
                                            bottom: line,
                                        });
                                    }
                                }
                            }
                        };
                        for (var x = -1; x <= matrix.width; x++) {
                            _loop_2(x);
                        }
                        finderPatternQuads.push.apply(
                            finderPatternQuads,
                            activeFinderPatternQuads.filter(function (q) {
                                return (
                                    q.bottom.y !== y &&
                                    q.bottom.y - q.top.y >= 2
                                );
                            })
                        );
                        activeFinderPatternQuads =
                            activeFinderPatternQuads.filter(function (q) {
                                return q.bottom.y === y;
                            });
                        alignmentPatternQuads.push.apply(
                            alignmentPatternQuads,
                            activeAlignmentPatternQuads.filter(function (q) {
                                return q.bottom.y !== y;
                            })
                        );
                        activeAlignmentPatternQuads =
                            activeAlignmentPatternQuads.filter(function (q) {
                                return q.bottom.y === y;
                            });
                    };
                    for (var y = 0; y <= matrix.height; y++) {
                        _loop_1(y);
                    }
                    finderPatternQuads.push.apply(
                        finderPatternQuads,
                        activeFinderPatternQuads.filter(function (q) {
                            return q.bottom.y - q.top.y >= 2;
                        })
                    );
                    alignmentPatternQuads.push.apply(
                        alignmentPatternQuads,
                        activeAlignmentPatternQuads
                    );
                    var finderPatternGroups = finderPatternQuads
                        .filter(function (q) {
                            return q.bottom.y - q.top.y >= 2;
                        }) // All quads must be at least 2px tall since the center square is larger than a block
                        .map(function (q) {
                            var x =
                                (q.top.startX +
                                    q.top.endX +
                                    q.bottom.startX +
                                    q.bottom.endX) /
                                4;
                            var y = (q.top.y + q.bottom.y + 1) / 2;
                            if (!matrix.get(Math.round(x), Math.round(y))) {
                                return;
                            }
                            var lengths = [
                                q.top.endX - q.top.startX,
                                q.bottom.endX - q.bottom.startX,
                                q.bottom.y - q.top.y + 1,
                            ];
                            var size = sum(lengths) / lengths.length;
                            var score = scorePattern(
                                { x: Math.round(x), y: Math.round(y) },
                                [1, 1, 3, 1, 1],
                                matrix
                            );
                            return { score: score, x: x, y: y, size: size };
                        })
                        .filter(function (q) {
                            return !!q;
                        }) // Filter out any rejected quads from above
                        .sort(function (a, b) {
                            return a.score - b.score;
                        })
                        // Now take the top finder pattern options and try to find 2 other options with a similar size.
                        .map(function (point, i, finderPatterns) {
                            if (i > MAX_FINDERPATTERNS_TO_SEARCH) {
                                return null;
                            }
                            var otherPoints = finderPatterns
                                .filter(function (p, ii) {
                                    return i !== ii;
                                })
                                .map(function (p) {
                                    return {
                                        x: p.x,
                                        y: p.y,
                                        score:
                                            p.score +
                                            Math.pow(p.size - point.size, 2) /
                                                point.size,
                                        size: p.size,
                                    };
                                })
                                .sort(function (a, b) {
                                    return a.score - b.score;
                                });
                            if (otherPoints.length < 2) {
                                return null;
                            }
                            var score =
                                point.score +
                                otherPoints[0].score +
                                otherPoints[1].score;
                            return {
                                points: [point].concat(otherPoints.slice(0, 2)),
                                score: score,
                            };
                        })
                        .filter(function (q) {
                            return !!q;
                        }) // Filter out any rejected finder patterns from above
                        .sort(function (a, b) {
                            return a.score - b.score;
                        });
                    if (finderPatternGroups.length === 0) {
                        return null;
                    }
                    var _a = reorderFinderPatterns(
                            finderPatternGroups[0].points[0],
                            finderPatternGroups[0].points[1],
                            finderPatternGroups[0].points[2]
                        ),
                        topRight = _a.topRight,
                        topLeft = _a.topLeft,
                        bottomLeft = _a.bottomLeft;
                    var alignment = findAlignmentPattern(
                        matrix,
                        alignmentPatternQuads,
                        topRight,
                        topLeft,
                        bottomLeft
                    );
                    var result = [];
                    if (alignment) {
                        result.push({
                            alignmentPattern: {
                                x: alignment.alignmentPattern.x,
                                y: alignment.alignmentPattern.y,
                            },
                            bottomLeft: { x: bottomLeft.x, y: bottomLeft.y },
                            dimension: alignment.dimension,
                            topLeft: { x: topLeft.x, y: topLeft.y },
                            topRight: { x: topRight.x, y: topRight.y },
                        });
                    }
                    // We normally use the center of the quads as the location of the tracking points, which is optimal for most cases and will account
                    // for a skew in the image. However, In some cases, a slight skew might not be real and instead be caused by image compression
                    // errors and/or low resolution. For those cases, we'd be better off centering the point exactly in the middle of the black area. We
                    // compute and return the location data for the naively centered points as it is little additional work and allows for multiple
                    // attempts at decoding harder images.
                    var midTopRight = recenterLocation(matrix, topRight);
                    var midTopLeft = recenterLocation(matrix, topLeft);
                    var midBottomLeft = recenterLocation(matrix, bottomLeft);
                    var centeredAlignment = findAlignmentPattern(
                        matrix,
                        alignmentPatternQuads,
                        midTopRight,
                        midTopLeft,
                        midBottomLeft
                    );
                    if (centeredAlignment) {
                        result.push({
                            alignmentPattern: {
                                x: centeredAlignment.alignmentPattern.x,
                                y: centeredAlignment.alignmentPattern.y,
                            },
                            bottomLeft: {
                                x: midBottomLeft.x,
                                y: midBottomLeft.y,
                            },
                            topLeft: { x: midTopLeft.x, y: midTopLeft.y },
                            topRight: { x: midTopRight.x, y: midTopRight.y },
                            dimension: centeredAlignment.dimension,
                        });
                    }
                    if (result.length === 0) {
                        return null;
                    }
                    return result;
                }
                exports.locate = locate;
                function findAlignmentPattern(
                    matrix,
                    alignmentPatternQuads,
                    topRight,
                    topLeft,
                    bottomLeft
                ) {
                    var _a;
                    // Now that we've found the three finder patterns we can determine the blockSize and the size of the QR code.
                    // We'll use these to help find the alignment pattern but also later when we do the extraction.
                    var dimension;
                    var moduleSize;
                    try {
                        (_a = computeDimension(
                            topLeft,
                            topRight,
                            bottomLeft,
                            matrix
                        )),
                            (dimension = _a.dimension),
                            (moduleSize = _a.moduleSize);
                    } catch (e) {
                        return null;
                    }
                    // Now find the alignment pattern
                    var bottomRightFinderPattern = {
                        x: topRight.x - topLeft.x + bottomLeft.x,
                        y: topRight.y - topLeft.y + bottomLeft.y,
                    };
                    var modulesBetweenFinderPatterns =
                        (distance(topLeft, bottomLeft) +
                            distance(topLeft, topRight)) /
                        2 /
                        moduleSize;
                    var correctionToTopLeft =
                        1 - 3 / modulesBetweenFinderPatterns;
                    var expectedAlignmentPattern = {
                        x:
                            topLeft.x +
                            correctionToTopLeft *
                                (bottomRightFinderPattern.x - topLeft.x),
                        y:
                            topLeft.y +
                            correctionToTopLeft *
                                (bottomRightFinderPattern.y - topLeft.y),
                    };
                    var alignmentPatterns = alignmentPatternQuads
                        .map(function (q) {
                            var x =
                                (q.top.startX +
                                    q.top.endX +
                                    q.bottom.startX +
                                    q.bottom.endX) /
                                4;
                            var y = (q.top.y + q.bottom.y + 1) / 2;
                            if (!matrix.get(Math.floor(x), Math.floor(y))) {
                                return;
                            }
                            var lengths = [
                                q.top.endX - q.top.startX,
                                q.bottom.endX - q.bottom.startX,
                                q.bottom.y - q.top.y + 1,
                            ];
                            var size = sum(lengths) / lengths.length;
                            var sizeScore = scorePattern(
                                { x: Math.floor(x), y: Math.floor(y) },
                                [1, 1, 1],
                                matrix
                            );
                            var score =
                                sizeScore +
                                distance(
                                    { x: x, y: y },
                                    expectedAlignmentPattern
                                );
                            return { x: x, y: y, score: score };
                        })
                        .filter(function (v) {
                            return !!v;
                        })
                        .sort(function (a, b) {
                            return a.score - b.score;
                        });
                    // If there are less than 15 modules between finder patterns it's a version 1 QR code and as such has no alignmemnt pattern
                    // so we can only use our best guess.
                    var alignmentPattern =
                        modulesBetweenFinderPatterns >= 15 &&
                        alignmentPatterns.length
                            ? alignmentPatterns[0]
                            : expectedAlignmentPattern;
                    return {
                        alignmentPattern: alignmentPattern,
                        dimension: dimension,
                    };
                }

                /***/
            },
            /******/
        ]
    )["default"];
});
